<template>
  <el-tabs @tab-click="handleClick" v-model="firstZL" >
    <el-tab-pane label="首页" name="firstZL">

      <el-row>
        集群基本信息
        <div>
          名称 访问地址 内存 CPU 节点数
        </div>

      </el-row>

      <nodelist></nodelist>

    </el-tab-pane>
    <el-tab-pane label="基础配置" name="common">

      <el-tabs :tab-position="tabPosition" style="height: 100%;">
        <el-tab-pane label="通用属性">
          <el-form label-width="200px" class="demo-ruleForm">
            <el-form-item label="join-distribution-type:" prop="join-distribution-type">
              <el-select v-model="data.common['common1']['join-distribution-type']" placeholder="请选择">
                <el-option label="AUTOMATIC" value="AUTOMATIC"></el-option>
                <el-option label="PARTITIONED" value="PARTITIONED"></el-option>
                <el-option label="BROADCAST" value="BROADCAST"></el-option>
              </el-select>
              <el-tooltip placement="top">
                <div slot="content">
                  要使用的分布式联接的类型。<br/> 设置为PARTITIONED时，openLooKeng将使用哈希分布式联接。
                  <br/>当设置为BROADCAST时，将向集群中所有从左表获得数据的节点广播右表。分区联接要求使用联接键的哈希重分布这两个表。
                  <br/>这可能比广播联接慢（有时极慢），但允许更大的联接。特别是如果右表比左表小得多，则广播联接将更快。
                  <br/>但是广播联接要求联接右侧过滤后的表适合每个节点的内存，而分布式联接只需要适合所有节点的分布式内存。
                  <br/>当设置为AUTOMATIC时，openLooKeng将基于成本决定哪种分布类型是最优的。
                  <br/>还将考虑将左右输入切换到联接。 在AUTOMATIC模式中，如果无法计算成本，例如表没有统计信息，openLooKeng将默认哈希分布式联接。
                  <br/>也可以使用join_distribution_type会话属性在每个查询基础上指定。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>


            <el-form-item label="redistribute-writes:" prop="redistribute-writes">
              <el-switch v-model="data.common['common1']['redistribute-writes']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性允许在写入数据之前重新分布数据。
                  <br/>这可以通过在集群中的节点间散列数据来消除数据倾斜带来的性能影响。
                  <br/>当已知输出数据集没有发生倾斜时，可以停用数据分布，以避免在网络上散列和重分布所有数据的开销。
                  <br/>也可以使用redistribute_writes会话属性在每个查询基础上指定。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="stack-trace-visible:" prop="stack-trace-visible">
              <el-switch v-model="data.common['common1']['stack-trace-visible']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性控制系统是否能够在CLI、WEB UI等对外展示系统出现Exception时的代码调用栈.
                  <br/>当设置为true时对外展示给所有用户，设置为false或者采用默认设置，不展示给任何用户。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="openlookeng.admins:" prop="openlookeng.admins">
              <el-input
                class="inputWidth"
                placeholder="不设置"
                v-model="data.common['common1']['openlookeng.admins']"
                :disabled="true">
              </el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性用于设置admin用户，admin用户具有获取所有用户查询历史、下载所有用户WEB UI查询结果的权限。
                  <br/>当设置为true时对外展示给所有用户，设置为false或者采用默认设置，不展示给任何用户。
                  <br/>默认不设置admin用户，当需要设置多个admin用户时，多个用户间使用逗号隔开。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>
          </el-form>
        </el-tab-pane>


        <el-tab-pane label="HTTP安全">
          <el-form label-width="320px" class="demo-ruleForm">
            <el-form-item label="http-header.content-security-policy:" prop="http-header.content-security-policy">
              <el-input class="inputWidth" v-model="data.common['common1']['http-header.content-security-policy']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性设置 content-security-policy 设置相关值。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="http-header.referrer-policy:" prop="http-header.referrer-policy">
              <el-input class="inputWidth" v-model="data.common['common1']['http-header.referrer-policy']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性设置 referrer-policy 设置相关值。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="http-header.x-content-type-options:" prop="http-header.x-content-type-options">
              <el-input class="inputWidth" v-model="data.common['common1']['http-header.x-content-type-options']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性设置 content-security-policy 设置相关值。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="http-header.x-frame-options:" prop="http-header.x-frame-options">
              <el-input class="inputWidth" v-model="data.common['common1']['http-header.x-frame-options']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性设置 content-security-policy 设置相关值。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="http-header.x-permitted-cross-domain-policies:"
                          prop="http-header.x-permitted-cross-domain-policies">
              <el-input class="inputWidth"
                        v-model="data.common['common1']['http-header.x-permitted-cross-domain-policies']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性设置 x-permitted-cross-domain-policies 设置相关值。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="http-header.x-xss-protection:" prop="http-header.x-xss-protection">
              <el-input class="inputWidth" v-model="data.common['common1']['http-header.x-xss-protection']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性设置 http-header.x-xss-protection 设置相关值。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

          </el-form>
        </el-tab-pane>


        <el-tab-pane label="内存管理">
          <el-form label-width="250px" class="demo-ruleForm">
            <el-form-item label="query.max-memory-per-node:" prop="query.max-memory-per-node">
              <el-input class="inputWidth" v-model="data.common['common1']['query.max-memory-per-node']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性是查询在工作节点上可以使用的最大用户内存量。用户内存是在执行期间为用户查询直接归属或可控制的事物分配的。
                  <br/>例如，在执行期间构建的哈希表使用的内存、排序期间使用的内存等。当任何工作节点上的查询的用户内存分配达到此限制时，该工作节点将被杀死。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="query.max-total-memory-per-node:" prop="query.max-total-memory-per-node">
              <el-input class="inputWidth" v-model="data.common['common1']['query.max-total-memory-per-node']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性是查询在工作节点上可以使用的最大用户和系统内存量。
                  <br/>系统内存是在执行期间为用户查询无法直接归属或可控制的事物分配的。
                  <br/>例如，由读取器、写入器、网络缓冲区等分配的内存。
                  <br/>当任何工作节点上的查询所分配的用户和系统内存的总和达到此限制时，该工作节点将被杀死。
                  <br/>query.max-total-memory-per-node的值必须大于query.max-memory-per-node。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="query.max-memory:" prop="query.max-memory">
              <el-input class="inputWidth" v-model="data.common['common1']['query.max-memory']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性是查询在整个集群上可以使用的最大用户内存量。
                  <br/>用户内存是在执行期间为用户查询直接归属或可控制的事物分配的。
                  <br/>例如，在执行期间构建的哈希表使用的内存、排序期间使用的内存等。
                  <br/>当一个跨所有工作节点的查询的用户内存分配达到此限制时，该工作节点将被杀死。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="query.max-total-memory:" prop="query.max-total-memory">
              <el-input class="inputWidth" v-model="data.common['common1']['query.max-total-memory']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性是查询在整个集群上可以使用的最大用户和系统内存量。
                  <br/>系统内存是在执行期间为用户查询无法直接归属或可控制的事物分配的。
                  <br/>例如，由读取器、写入器、网络缓冲区等分配的内存。
                  <br/>当一个跨所有工作节点的查询所分配的用户和系统内存的总和达到此限制时，该工作节点将被杀死。
                  <br/>query.max-total-memory的值必须大于query.max-memory。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="memory.heap-headroom-per-node:" prop="memory.heap-headroom-per-node">
              <el-input class="inputWidth" v-model="data.common['common1']['memory.heap-headroom-per-node']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性是在JVM堆中为openLooKeng不跟踪的分配留作裕量/缓冲区的内存量。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

          </el-form>
        </el-tab-pane>
        <el-tab-pane label="溢出属性">
          <el-form label-width="250px" class="demo-ruleForm">
            <el-form-item label="experimental.spill-enabled:" prop="experimental.spill-enabled">
              <el-switch v-model="data.common['common1']['experimental.spill-enabled']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  尝试将内存溢出到磁盘，以避免超出查询的内存限制。
                  <br/>溢出是将内存卸载到磁盘。此过程允许内存占用大的查询，代价是执行时间变慢。聚合、联接（内联接和外联接）、排序和窗口函数支持溢出。
                  <br/>此属性不会减少其他联接类型所需的内存使用。
                  <br/>注意，这是一个实验特性，应谨慎使用。
                  <br/>此配置属性可由spill_enabled会话属性重写。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="experimental.spill-order-by:" prop="experimental.spill-order-by">
              <el-switch v-model="data.common['common1']['experimental.spill-order-by']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  尝试将内存溢出到磁盘，以避免在运行排序运算符时超出查询的内存限制。
                  <br/>此属性必须与experimental.spill-enabled属性一起使用。
                  <br/>此配置属性可由spill_order_by会话属性重写。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="experimental.spill-window-operator:" prop="experimental.spill-window-operator">
              <el-switch v-model="data.common['common1']['experimental.spill-window-operator']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  尝试将内存溢出到磁盘，以避免在运行窗口运算符时超出查询的内存限制。
                  <br/>此属性必须与experimental.spill-enabled属性一起使用。
                  <br/>此配置属性可由spill_window_operator会话属性重写。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="experimental.spill-reuse-tablescan:" prop="experimental.spill-reuse-tablescan">
              <el-switch v-model="data.common['common1']['experimental.spill-reuse-tablescan']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  尝试将内存溢出到磁盘，以避免在运行Reuse Exchange时超出查询的内存限制。
                  <br/>此属性必须与experimental.spill-enabled属性一起使用。
                  <br/>此配置属性可由spill_reuse_tablescan会话属性重写。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="experimental.spiller-spill-path`:" prop="experimental.spiller-spill-path`">
              <el-input class="inputWidth" v-model="data.common['common1']['experimental.spiller-spill-path`']"
                        placeholder="无默认值,启用溢出时必须设置"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  溢出内容写入的目录。
                  <br/>该属性可以是一个逗号分隔的列表，以同时溢出到多个目录，这有助于利用系统中安装的多个驱动器。
                  <br/>不建议溢出到系统驱动器上。最重要的是，不要溢出到写入JVM日志的驱动器，因为磁盘过度使用可能导致JVM长时间暂停，从而导致查询失败。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>
          </el-form>
        </el-tab-pane>

        <el-tab-pane label="交换属性">
          <el-form label-width="290px" class="demo-ruleForm">
            <el-form-item label="exchange.client-threads:" prop="exchange.client-threads">
              <el-input class="inputWidth" v-model="data.common['common1']['exchange.client-threads']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  交换客户端从其他openLooKeng节点获取数据的线程数。
                  <br/>对于大型集群或并发量非常高的集群，设置较高的值可以提高性能，但是过高的值可能会由于上下文切换和额外的内存使用而导致性能下降。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="exchange.concurrent-request-multiplier:" prop="exchange.concurrent-request-multiplier">
              <el-input class="inputWidth" v-model="data.common['common1']['exchange.concurrent-request-multiplier']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  确定相对于可用缓冲区内存的并发请求数的乘数。
                  <br/>根据每个请求的平均缓冲区使用量乘以该乘数，使用可适合可用缓冲区空间的客户端数量的启发式方法来确定最大请求数。
                  <br/>例如，如果已经使用了exchange.max-buffer-size为32 MB和20 MB，每个请求的平均大小为2MB，
                  <br/>则客户端的最大数量为multiplier * ((32MB - 20MB) / 2MB) = multiplier * 6。调整此值可以调整启发式，可能会增加并发度并提高网络利用率。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="exchange.max-buffer-size:" prop="exchange.max-buffer-size">
              <el-input class="inputWidth" v-model="data.common['common1']['exchange.max-buffer-size']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  交换客户端中保存处理前从其他节点取出的数据的缓冲区大小。
                  <br/>较大的缓冲区可以提高较大集群的网络吞吐量，从而减少查询处理时间，但会减少可用于其他用途的内存量。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="exchange.max-response-size:" prop="exchange.max-response-size">
              <el-input class="inputWidth" v-model="data.common['common1']['exchange.max-response-size']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  交换请求返回的最大响应大小。
                  <br/>响应将被放置在交换客户机缓冲区中，该缓冲区在交换的所有并发请求之间共享。
                  <br/>如果网络延迟较高，增大该值可以提高网络吞吐量。减小该值可以提高大型集群的查询性能，
                  <br/>因为它减少了由于交换客户端缓冲区保存了较多任务（而不是保存较少任务中的较多数据）的响应而导致的倾斜。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="exchange.max-error-duration:" prop="exchange.max-error-duration">
              <el-input class="inputWidth" v-model="data.common['common1']['exchange.max-error-duration']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  交换错误最大缓冲时间，超过该时限则查询失败。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="sink.max-buffer-size:" prop="sink.max-buffer-size">
              <el-input class="inputWidth" v-model="data.common['common1']['sink.max-buffer-size']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  上游任务等待拉取任务数据的输出缓冲区大小。
                  <br/>如果任务输出是经过哈希分区的，那么缓冲区将在所有分区的使用者之间共享。
                  <br/>如果网络延迟较高或集群中有多个节点，增加此值可以提高在阶段之间传输的数据的网络吞吐量。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

          </el-form>
        </el-tab-pane>

        <el-tab-pane label="任务属性">
          <el-form label-width="290px" class="demo-ruleForm">

            <el-form-item label="task.concurrency:" prop="task.concurrency">
              <el-input class="inputWidth" v-model="data.common['common1']['task.concurrency']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  限制： 必须是2的幂。
                  <br/>并行运算符（如联接和聚合）的默认本地并发度。
                  <br/>该值应根据查询并发度和工作节点资源使用情况向上或向下调整。
                  <br/>对于同时运行许多查询的集群来说，该值越低越好，因为所有正在运行的查询都已经利用了集群，所以增加更多的并发度将由于上下文切换和其他开销而导致速度变慢。
                  <br/>对于一次只运行一个或较少查询的集群，该值越高越好。也可以使用task_concurrency会话属性在每个查询基础上指定。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="task.http-response-threads:" prop="ttask.http-response-threads">
              <el-input class="inputWidth" v-model="data.common['common1']['task.http-response-threads']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  可以创建用于处理HTTP响应的最大线程数。
                  <br/>线程是按需创建的，在空闲时被清理。
                  <br/>因此，如果待处理的请求数量很少，则不会产生大量开销。
                  <br/>在并发查询数高的集群上或在有数百或数千个工作节点的集群上，更多的线程可能会有帮助。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="task.http-timeout-threads:" prop="task.http-timeout-threads">
              <el-input class="inputWidth" v-model="data.common['common1']['task.http-timeout-threads']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  生成HTTP响应时用于处理超时的线程数。
                  <br/>如果所有线程都频繁使用，则应增大此值。
                  <br/>这可以通过io.prestosql.core.server:name=AsyncHttpExecutionMBean:TimeoutExecutor JMX对象进行监视。
                  <br/>如果ActiveCount始终与PoolSize相同，则增加线程数。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="task.info-update-interval:" prop="task.info-update-interval">
              <el-input class="inputWidth" v-model="data.common['common1']['task.info-update-interval']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  控制任务信息的时效性，用于调度。较大的值可以降低协调节点CPU负载，但可能导致次优的分片调度。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="task.max-partial-aggregation-memory:" prop="task.max-partial-aggregation-memory">
              <el-input class="inputWidth" v-model="data.common['common1']['task.max-partial-aggregation-memory']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  分布式聚合时部分聚合结果的最大大小。
                  <br/>增大此值可以允许在刷新之前在本地保留更多的组，从而减少网络传输和CPU利用率，但要以增加内存利用率为代价。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="task.max-worker-threads:" prop="task.max-worker-threads">
              <el-input class="inputWidth" v-model="data.common['common1']['task.max-worker-threads']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  设置工作节点用来处理分片的线程数。<br/>
                  如果工作节点CPU利用率较低且所有线程都在使用，则增加此数量可以提高吞吐量，但会导致堆空间使用率增加。
                  <br/>设置过高的值可能会由于上下文切换而导致性能下降。
                  <br/>通过io.prestosql.core.execution.executor:name=TaskExecutor.RunningSplits
                  JXM对象的RunningSplits属性可以获得活动线程的数量。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="task.min-drivers:" prop="task.min-drivers">
              <el-input class="inputWidth" v-model="data.common['common1']['task.min-drivers']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  工作节点上运行中的叶子分片的目标个数。
                  <br/>这是一个最小值，因为每个叶任务保证至少3个运行分片。
                  <br/>还保证运行非叶子任务，以防止死锁。
                  <br/>较低的值可能提高对新任务的响应能力，但可能导致资源利用不足。较高的值可以提高资源利用率，但会占用额外的内存。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="task.writer-count:" prop="task.writer-count">
              <el-input class="inputWidth" v-model="data.common['common1']['task.writer-count']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  限制： 必须是2的幂<br/>
                  每个工作节点每个查询的并发写入器线程数。
                  <br/>增加该值可以提高写入速度，尤其在查询不是I/O绑定并且可以利用额外的CPU进行并行写入时。
                  <br/>（某些连接器由于压缩或其他原因，在写入时可能会在CPU上出现瓶颈）.设置该值过高可能导致集群因资源使用率过高而过载。
                  <br/>也可以使用task_writer_count会话属性在每个查询基础上指定。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

          </el-form>
        </el-tab-pane>

        <el-tab-pane label="节点调度器属性">
          <el-form label-width="320px" class="demo-ruleForm">

            <el-form-item label="node-scheduler.max-splits-per-node:" prop="node-scheduler.max-splits-per-node">
              <el-input class="inputWidth" v-model="data.common['common1']['node-scheduler.max-splits-per-node']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  每个工作节点可以运行的分片总数的目标值。
                  <br/>如果要批量提交查询（例如，定期运行大量报告），或者对于产生许多分片且快速完成的连接器，建议使用较高的值。
                  <br/>增加此值可以确保工作节点有足够的分片来充分利用，从而改善查询延迟。
                  <br/>设置此值过高将浪费内存，并可能导致性能降低，因为分片在工作节点之间不平衡。
                  <br/>理想情况下，应该设置始终至少有一个分片等待处理，但不要更高。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="node-scheduler.max-pending-splits-per-task:"
                          prop="node-scheduler.max-pending-splits-per-task">
              <el-input class="inputWidth"
                        v-model="data.common['common1']['node-scheduler.max-pending-splits-per-task']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  每个工作节点在单个查询阶段可以排队等待的未处理分片数，即使该节点已经处于总分片数的限制。
                  <br/>每个阶段需要允许最小数量的分片以防止饥饿和死锁。
                  <br/>此值必须小于node-scheduler.max-splits-per-node，通常由于相同的原因而增加。
                  <br/>如果设置过高，也有类似的缺点。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="node-scheduler.min-candidates:" prop="node-scheduler.min-candidates">
              <el-input class="inputWidth" v-model="data.common['common1']['node-scheduler.min-candidates']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  选择分片的目标节点时节点调度器将评估的最小候选节点数。
                  <br/>将此值设置过低可能会使无法在所有工作节点之间适当平衡。
                  <br/>将此值设置过高可能会增加查询延迟，并增加协调器CPU使用率。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="node-scheduler.network-topology:" prop="node-scheduler.network-topology">
              <el-select v-model="data.common['common1']['node-scheduler.network-topology']" placeholder="请选择">
                <el-option label="legacy" value='legacy'></el-option>
                <el-option label="flat" value="flat"></el-option>
              </el-select>
              <el-tooltip placement="top">
                <div slot="content">
                  设置调度分片时使用的网络拓扑。legacy调度分片时忽略拓扑。
                  <br/>flat会尝试在数据所在的主机上调度分片，为本地分片预留50%的工作队列。
                  <br/>对于分布式存储与openLooKeng worker运行在相同节点上的集群，推荐使用flat。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

          </el-form>
        </el-tab-pane>

        <el-tab-pane label="优化器属性">
          <el-form label-width="290px" class="demo-ruleForm">

            <el-form-item label="optimizer.dictionary-aggregation:" prop="optimizer.dictionary-aggregation">
              <el-switch v-model="data.common['common1']['optimizer.dictionary-aggregation']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  对字典上的聚合启用优化。也可以使用dictionary_aggregation会话属性在每个查询基础上指定。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="optimizer.optimize-hash-generation:" prop="optimizer.optimize-hash-generation">
              <el-switch v-model="data.common['common1']['optimizer.optimize-hash-generation']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  在执行期间的早期为分布、联接和聚合计算哈希代码，允许在查询的后期在操作之间共享结果。
                  <br/>这可以通过避免多次计算相同的哈希来降低CPU使用率，但代价是为哈希进行额外的网络传输。
                  <br/>在大多数情况下，这将减少整个查询处理时间。也可以使用optimize_hash_generation会话属性在每个查询基础上指定。
                  <br/>在使用EXPLAIN时禁用此属性通常很有帮助，这样可以使查询计划更易读。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="optimizer.optimize-metadata-queries:" prop="optimizer.optimize-metadata-queries">
              <el-switch v-model="data.common['common1']['optimizer.optimize-metadata-queries']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  通过使用存储为元数据的值来启用对一些聚合的优化。
                  <br/>这允许openLooKeng在恒定的时间内执行一些简单的查询。
                  <br/>目前，该优化适用于分区键的max、min和approx_distinct，以及其它对输入（包括DISTINCT聚集）的基数不敏感的聚集。
                  <br/>使用此属性可以大大加快某些查询的速度。
                  <br/>主要的缺点是，如果连接器为没有行的分区返回分区键，可能会产生不正确的结果。
                  <br/>特别是，如果空分区是由其他系统创建的（openLooKeng不能创建），那么Hive连接器可以返回空分区。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="optimizer.push-aggregation-through-join:"
                          prop="optimizer.push-aggregation-through-join">
              <el-switch v-model="data.common['common1']['optimizer.push-aggregation-through-join']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  如果聚合位于外联接上，并且来自联接外部的所有列都在分组子句中，则聚合被推送到外联接之下。
                  <br/>这种优化对于相关的标量子查询尤其有用，这些子查询通过外联接被重写为聚合。
                  <br/>启用此优化可以减少联接需要处理的数据量，从而大大加快查询速度。
                  <br/>但是，此优化可能会减慢一些具有非常选择性联接的查询。
                  <br/>也可以使用push_aggregation_through_join会话属性在每个查询基础上指定。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="optimizer.push-table-write-through-union:"
                          prop="optimizer.push-table-write-through-union">
              <el-switch v-model="data.common['common1']['optimizer.push-table-write-through-union']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  在写入数据的查询中使用UNION ALL时，对写入进行并行化。
                  <br/>这提高了在UNION ALL查询中写入输出表的速度，因为这些写入在收集结果时不需要额外的同步。
                  <br/>当写入速度尚未饱和时，启用此优化可以提高UNION ALL速度。但是，此优化可能会减慢负载已经很重的系统中的查询。
                  <br/>也可以使用push_table_write_through_union会话属性在每个查询基础上指定。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="optimizer.join-reordering-strategy:" prop="optimizer.join-reordering-strategy">
              <el-select v-model="data.common['common1']['optimizer.join-reordering-strategy']" placeholder="请选择">
                <el-option label="AUTOMATIC" value="AUTOMATIC"></el-option>
                <el-option label="ELIMINATE_CROSS_JOINS" value="ELIMINATE_CROSS_JOINS"></el-option>
                <el-option label="NONE" value="NONE"></el-option>
              </el-select>
              <el-tooltip placement="top">
                <div slot="content">
                  要使用的联接重新排序策略。
                  <br/>NONE维持查询中列出的表的顺序。
                  <br/>ELIMINATE_CROSS_JOINS重新排序联接，以尽可能消除交叉联接，否则保持原始查询顺序。
                  <br/>当重新排序连接时，该值还尽可能地保持原来的表顺序。
                  <br/>AUTOMATIC枚举可能的顺序并使用基于统计的成本估计来确定最小成本顺序。
                  <br/>如果统计数据不可用，或者由于任何原因无法计算成本，则使用ELIMINATE_CROSS_JOINS策略。
                  <br/>也可以使用join_reordering_strategy会话属性在每个查询基础上指定。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="optimizer.max-reordered-joins:" prop="optimizer.max-reordered-joins">
              <el-input class="inputWidth" v-model="data.common['common1']['optimizer.max-reordered-joins']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  当optimizer.join-reordering-strategy设置为基于成本时，此属性确定可一次重新排序的最大联接数。
                  <br/>警告： 可能的连接顺序数随着关系数的增大而增大，因此增加此值会导致严重的性能问题。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="hetu.query-pushdown:" prop="hetu.query-pushdown">
              <el-switch v-model="data.common['common1']['hetu.query-pushdown']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  控制jdbc connector及dc connector下推的总开关。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="optimizer.reuse-table-scan:" prop="optimizer.reuse-table-scan">
              <el-switch v-model="data.common['common1']['optimizer.reuse-table-scan']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  如果查询包含的表或公用表表达式（CTE）出现多次且具有相同的投影和过滤器，则使用Reuse Exchange来将数据缓存在内存中。
                  <br/>启用此功能将通过将数据缓存在内存中并避免多次从磁盘读取来减少执行查询所需的时间。
                  <br/>也可以使用reuse_table_scan会话属性在每个查询基础上指定。
                  <br/>注意：当启用cte_reuse_enabled或optimizer.cte-reuse-enabled时，重用交换将被禁用。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="optimizer.cte-reuse-enabled:" prop="optimizer.cte-reuse-enabled">
              <el-switch v-model="data.common['common1']['optimizer.cte-reuse-enabled']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  启用此标志后，无论主查询中使用同一CTE多少次，都仅执行一次公用表表达式（CTE）。
                  <br/>当多次使用同一个CTE时，这将有助于提高查询执行性能。
                  <br/>也可以使用 cte_reuse_enabled 会话属性对每个查询指定。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="optimizer.sort-based-aggregation-enabled:"
                          prop="optimizer.sort-based-aggregation-enabled">
              <el-switch v-model="data.common['common1']['optimizer.sort-based-aggregation-enabled']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  当基础源处于预排序顺序时，使用基于排序的聚合，而不是哈希聚合，后者需要占用更多的空间来构建哈希表。
                  <br/>与哈希聚合相比，基于排序的聚合占用的内存空间较少。 Hive中基于排序聚合的条件
                  <br/>分组列数量应等于或小于排序列，且顺序应与排序列相同。
                  <br/>Join探针侧表应排序，Join条件数量应等于或小于已排序列，且顺序应与排序列相同。
                  <br/>当bucket_count为1时，bucketed_by列数量应等于或小于分组列，且顺序应与分组列相同。
                  <br/>当bucket_count大于1时，bucketed_by列数量和顺序应与分组列相同。
                  <br/>针对分区表，分组列应包含所有分区，顺序与按列排序的子集顺序一致。
                  <br/>使用 distinct 时，带有distinct列的分组列应该是排序列集合的子集。
                  <br/>也可以使用sort_based_aggregation_enabled会话属性在每个查询上指定。
                  <br/>注意： 仅适用于Hive连接器。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

          </el-form>
        </el-tab-pane>

        <el-tab-pane label="正则表达式函数属性">
          <el-form label-width="150px" class="demo-ruleForm">

            <el-form-item label="regex-library:" prop="regex-library">
              <el-select v-model="data.common['common1']['regex-library']" placeholder="请选择">
                <el-option label="JONI" value="JONI"></el-option>
                <el-option label="RE2J" value="RE2J"></el-option>
              </el-select>
              <el-tooltip placement="top">
                <div slot="content">
                  用于正则表达式函数的库。一般来说，JONI对于一般用途的速度要快一些，但是对于某些表达式模式可能需要指数级的时间。
                  <br/>RE2J使用不同的算法保证线性时间，但通常速度较慢。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="re2j.dfa-states-limit:" prop="re2j.dfa-states-limit">
              <el-input class="inputWidth" v-model="data.common['common1']['re2j.dfa-states-limit']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  RE2J在为正则表达式匹配构建快速但可能占用大量内存的确定性有限自动机（DFA）时所使用的最大状态数。
                  <br/>如果达到限制，RE2J将回落到使用速度较慢但较少内存密集型非确定性有限自动机（NFA）的算法。
                  <br/>减小此值会降低正则表达式搜索的最大内存占用，但会牺牲速度。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="re2j.dfa-retries:" prop="re2j.dfa-retries">
              <el-input class="inputWidth" v-model="data.common['common1']['re2j.dfa-retries']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  在RE2J使用较慢但较少内存密集型的NFA算法对所有后续输入进行搜索前，如果DFA算法达到状态限制，RE2J将重试该算法的次数。
                  <br/>如果遇到给定输入行的极限值可能是离群值，那么你希望能够使用更快的DFA算法来处理后续行。
                  <br/>如果你也有可能达到匹配后续行的限制，那么你应该从头开始使用正确的算法，以避免浪费时间和资源。处理的行数越多，该值应该越大。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

          </el-form>
        </el-tab-pane>

        <el-tab-pane label="启发式索引属性">
          <el-form label-width="340px" class="demo-ruleForm">

            <el-form-item label="hetu.heuristicindex.filter.enabled:" prop="hetu.heuristicindex.filter.enabled">
              <el-switch v-model="data.common['common1']['hetu.heuristicindex.filter.enabled']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性启用启发式索引。
                  <br/>还有一个会话属性heuristicindex_filter_enabled，可按会话设置。
                  <br/>注意：当配置文件中将此全局属性设置为true时，会话属性仅用于临时打开和关闭索引筛选。
                  <br/>当未全局启用索引筛选器时，无法使用该会话属性来打开。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="hetu.heuristicindex.filter.cache.max-memory:"
                          prop="hetu.heuristicindex.filter.cache.max-memory">
              <el-input class="inputWidth"
                        v-model="data.common['common1']['hetu.heuristicindex.filter.cache.max-memory']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  由于索引文件很少被改动，将索引缓存可以提升性能，减少从文件系统读取索引所需时间。
                  <br/>这一属性控制索引缓存允许使用的内存大小，当缓存已满，最旧的缓存将被移除，由新的缓存替代（LRU缓存）。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="hetu.heuristicindex.filter.cache.soft-reference:"
                          prop="hetu.heuristicindex.filter.cache.soft-reference">
              <el-switch
                v-model="data.common['common1']['hetu.heuristicindex.filter.cache.soft-reference']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  缓存索引可以提供更好的性能，但是需要使用一部分内存空间。启用这一属性将允许垃圾回收器（GC）在内存不足时从缓存中清除内容来释放内存。
                  <br/>注意：这一特性还在实验中，请谨慎使用！
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="hetu.heuristicindex.filter.cache.ttl:" prop="hetu.heuristicindex.filter.cache.ttl">
              <el-input class="inputWidth" v-model="data.common['common1']['hetu.heuristicindex.filter.cache.ttl']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  索引缓存的有效时间。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="hetu.heuristicindex.filter.cache.loading-threads:"
                          prop="hetu.heuristicindex.filter.cache.loading-threads">
              <el-input class="inputWidth"
                        v-model="data.common['common1']['hetu.heuristicindex.filter.cache.loading-threads']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  从索引存储文件系统并行加载索引时使用的线程数量。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="hetu.heuristicindex.filter.cache.loading-delay:"
                          prop="hetu.heuristicindex.filter.cache.loading-delay">
              <el-input class="inputWidth"
                        v-model="data.common['common1']['hetu.heuristicindex.filter.cache.loading-delay']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  在异步加载索引到缓存前等待的时长。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="hetu.heuristicindex.filter.cache.preload-indices:"
                          prop="hetu.heuristicindex.filter.cache.preload-indices">
              <el-input class="inputWidth"
                        v-model="data.common['common1']['hetu.heuristicindex.filter.cache.preload-indices']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  在服务器启动时预加载指定名称的索引(用逗号分隔), 当值为ALL时将预载入全部索引。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="hetu.heuristicindex.indexstore.uri:" prop="hetu.heuristicindex.indexstore.uri">
              <el-input class="inputWidth" v-model="data.common['common1']['hetu.heuristicindex.indexstore.uri']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  所有索引文件存储在的目录。 每个索引将存储在其自己的子目录中。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="hetu.heuristicindex.indexstore.filesystem.profile:"
                          prop="hetu.heuristicindex.indexstore.filesystem.profile">
              <el-input class="inputWidth"
                        v-model="data.common['common1']['hetu.heuristicindex.indexstore.filesystem.profile']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性定义用于读取和写入索引的文件系统配置文件。对应的配置文件必须存在于etc/filesystem中。
                  <br/>例如，如果将该属性设置为hetu.heuristicindex.filter.indexstore.filesystem.profile=index-hdfs1，
                  <br/>则必须在etc/filesystem中创建描述该文件系统访问的配置文件index-hdfs1.properties，其中包含的必要信息包括身份验证类型、配置和密钥表（如适用）。
                  <br/>LOCAL文件系统类型仅应在测试期间或单节点群集中使用。
                  <br/>应在生产中使用HDFS文件系统类型，以便集群中的所有节点都能访问索引。所有节点都应配置为使用相同的文件系统配置文件。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

          </el-form>
        </el-tab-pane>

        <el-tab-pane label="执行计划缓存属性">
          <el-form label-width="250px" class="demo-ruleForm">

            <el-form-item label="hetu.executionplan.cache.enabled:" prop="hetu.executionplan.cache.enabled">
              <el-switch v-model="data.common['common1']['hetu.executionplan.cache.enabled']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  启用或禁用执行计划缓存。 默认禁用。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="hetu.executionplan.cache.limit:" prop="hetu.executionplan.cache.limit">
              <el-input class="inputWidth" v-model="data.common['common1']['hetu.executionplan.cache.limit']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  保留在缓存中的最大执行计划数
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="hetu.executionplan.cache.timeout:" prop="hetu.executionplan.cache.timeout">
              <el-input class="inputWidth" v-model="data.common['common1']['hetu.executionplan.cache.timeout']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  上次访问后使缓存的执行计划失效的时间（以毫秒为单位）
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

          </el-form>
        </el-tab-pane>

        <el-tab-pane label="SplitCacheMap属性">
          <el-form label-width="290px" class="demo-ruleForm">

            <el-form-item label="hetu.split-cache-map.enabled:" prop="hetu.split-cache-map.enabled">
              <el-switch v-model="data.common['common1']['hetu.split-cache-map.enabled']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性启用分片缓存功能。
                  <br/>如果启用了状态存储，则分片缓存映射配置也会自动复制到状态存储中。
                  <br/>在具有多个协调器的HA设置的情况下，状态存储用于在协调器之间共享分片的缓存映射。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="hetu.split-cache-map.state-update-interval:"
                          prop="hetu.split-cache-map.state-update-interval">
              <el-input class="inputWidth"
                        v-model="data.common['common1']['hetu.split-cache-map.state-update-interval']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性控制在状态存储中更新分割缓存映射的频率。 它主要适用于HA部署。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

          </el-form>
        </el-tab-pane>

        <el-tab-pane label="自动清空">
          <el-form label-width="250px" class="demo-ruleForm">

            <el-form-item label="auto-vacuum.enabled:" prop="auto-vacuum.enabled">
              <el-switch v-model="data.common['common1']['auto-vacuum.enabled:']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性用于启用自动清空功能。
                  <br/>注意： 此属性只能在协调节点中配置。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="auto-vacuum.scan.interval:" prop="auto-vacuum.scan.interval">
              <el-input class="inputWidth" v-model="data.common['common1']['auto-vacuum.scan.interval']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性为从数据源获取情况表信息并触发对这些表的清空操作的定时间隔。
                  <br/>计时器在服务器启动时开始，并将在配置的间隔内保持调度。最小值为15s，最大值为24h。
                  <br/>注意： 此属性只能在协调节点中配置。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="auto-vacuum.scan.threads:" prop="auto-vacuum.scan.threads">
              <el-input class="inputWidth" v-model="data.common['common1']['auto-vacuum.scan.threads']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  用于自动清空功能的线程数。最小值为1，最大值为16。
                  <br/>注意： 此属性只能在协调节点中配置。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

          </el-form>
        </el-tab-pane>

        <el-tab-pane label="CTE属性">
          <el-form label-width="250px" class="demo-ruleForm">

            <el-form-item label="cte.cte-max-queue-size:" prop="cte.cte-max-queue-size">
              <el-input class="inputWidth" v-model="data.common['common1']['cte.cte-max-queue-size']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  每个处理队列的最大页数。处理队列的数量等于主查询中的CTE引用的数量。
                  <br/>也可以使用 cte_max_queue_size 会话属性对每个查询指定。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="cte.cte-max-prefetch-queue-size:" prop="cte.cte-max-prefetch-queue-size">
              <el-input class="inputWidth" v-model="data.common['common1']['cte.cte-max-prefetch-queue-size']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  处理队列已满时，预取队列可以容纳的最大页数。预取队列用于急切读取数据，从而无需等待I/O执行查询。
                  <br/>也可以使用 cte_max_prefetch_queue_size会话属性对每个查询指定。
                  <br/>说明： 应在所有工作节点上配置该属性。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

          </el-form>
        </el-tab-pane>

        <el-tab-pane label="排序基础聚合属性">
          <el-form label-width="250px" class="demo-ruleForm">

            <el-form-item label="sort.prcnt-drivers-for-partial-aggr:" prop="sort.prcnt-drivers-for-partial-aggr">
              <el-input class="inputWidth" v-model="data.common['common1']['sort.prcnt-drivers-for-partial-aggr']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  在基于排序的聚合中，用于未完成/部分值的驱动程序数的百分比。
                  <br/>也可以使用prcnt_drivers_for_partial_aggr会话属性在每个查询上指定。
                  <br/>注意： 应在所有节点上配置该属性。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

          </el-form>
        </el-tab-pane>

        <el-tab-pane label="查询管理">
          <el-form label-width="290px" class="demo-ruleForm">

            <el-form-item label="query.remote-task.max-error-duration:" prop="query.remote-task.max-error-duration">
              <el-input class="inputWidth" v-model="data.common['common1']['query.remote-task.max-error-duration']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  远程任务错误最大缓冲时间，超过该时限则查询失败。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

          </el-form>
        </el-tab-pane>

        <el-tab-pane label="分布式快照">
          <el-form label-width="250px" class="demo-ruleForm">

            <el-form-item label="snapshot_enabled:" prop="snapshot_enabled">
              <el-switch v-model="data.common['common1']['snapshot_enabled:']"></el-switch>
              <el-tooltip placement="top">
                <div slot="content">
                  此会话属性用于启用或禁用分布式快照功能。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="hetu.experimental.snapshot.profile:" prop="hetu.experimental.snapshot.profile">
              <el-input class="inputWidth" v-model="data.common['common1']['hetu.experimental.snapshot.profile']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性定义用于存储快照的文件系统配置文件。对应的配置文件必须存在于etc/filesystem中。
                  <br/>例如，如果将该属性设置为hetu.experimental.snapshot.profile=snapshot-hdfs1，
                  <br/>则必须在etc/filesystem中创建描述此文件系统的配置文件snapshot-hdfs1.properties，
                  <br/>其中包含的必要信息包括身份验证类型、配置和密钥表（如适用）。具体细节请参考文件系统相关章节。
                  <br/>如在打开分布式快照的情况下执行任何查询时，需要配本属性。此属性必须包含在所有协调节点和工作节点的配置文件中。
                  <br/>指定的文件系统必须可由所有工作节点访问，且这些工作节点必须能够读取和写入指定文件系统中的/tmp/hetu/snapshot文件夹。
                  <br/>作为实验性属性，或可以将快照存储在非文件系统位置，如连接器。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="hetu.snapshot.maxRetries:" prop="hetu.snapshot.maxRetries">
              <el-input class="inputWidth" v-model="data.common['common1']['hetu.snapshot.maxRetries']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性定义查询的错误恢复尝试的最大次数。达到限制时，查询失败。
                  <br/>也可以使用snapshot_max_retries会话属性在每个查询基础上指定。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>

            <el-form-item label="hetu.snapshot.retryTimeout:" prop="hetu.snapshot.retryTimeout">
              <el-input class="inputWidth" v-model="data.common['common1']['hetu.snapshot.retryTimeout']"
                        placeholder="请输入内容"></el-input>
              <el-tooltip placement="top">
                <div slot="content">
                  此属性定义系统等待所有任务成功恢复的最大时长。如果在此超时时限内任何任务未就绪，
                  <br/>则认为恢复失败，查询将尝试从较早快照恢复（如果可用）。
                  <br/>也可以使用snapshot_retry_timeout会话属性在每个查询基础上指定。
                </div>
                <i class="el-icon-question"></i>
              </el-tooltip>
            </el-form-item>


          </el-form>
        </el-tab-pane>

      </el-tabs>


    </el-tab-pane>
    <el-tab-pane label="JVM配置" name="jvm">
      <el-input
        type="textarea"
        :rows="20"
        placeholder="请输入内容"
        v-model="data.jvm['jvm1'].jvm">
      </el-input>
      <el-row>
        <el-button>取消</el-button>
        <el-button type="primary" @click="saveConfig('jvm')">提交</el-button>
      </el-row>
    </el-tab-pane>
    <el-tab-pane label="连接器配置" name="dataSource">

      <el-tabs v-model="CarbonDataName" :tab-position="tabPosition" style="height: 100%;" @tab-click="handleClick">
        <el-tab-pane label="CarbonData连接器" name="CarbonData">

          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="连接器1" name="1">
              <el-form label-width="270px" class="demo-ruleForm">
                <el-form-item label="connector.name:" prop="connector.name">
                  <el-input class="inputWidth"
                            v-model="data.CarbonData['CarbonData1']['connector.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      用以创建etc/catalog/carbondata.properties，以将carbondata连接器挂载为carbondata目录
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.metastore.uri:" prop="hive.metastore.uri">
                  <el-input class="inputWidth"
                            v-model="data.CarbonData['CarbonData1']['hive.metastore.uri']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      使用Thrift协议连接Hive元存储的URI。
                      <br/>如果提供了多个URI，则默认使用第一个URI，其余URI为回退元存储。该属性必选。
                      <br/>示例：thrift://192.0.2.3:9083或thrift://192.0.2.3:9083,thrift://192.0.2.4:9083
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.metastore.username:" prop="hive.metastore.username">
                  <el-input class="inputWidth"
                            v-model="data.CarbonData['CarbonData1']['hive.metastore.username']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      openLooKeng用于访问Hive元存储的用户名。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.metastore.authentication.type:" prop="hive.metastore.authentication.type">
                  <el-select v-model="data.CarbonData['CarbonData1']['hive.metastore.authentication.type']"
                             placeholder="请选择">
                    <el-option label="NONE" value='NONE'></el-option>
                    <el-option label="KERBEROS" value="KERBEROS"></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Hive元存储身份验证类型。取值为NONE或KERBEROS（默认为NONE）。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.metastore.service.principal:" prop="hive.metastore.service.principal">
                  <el-input class="inputWidth"
                            v-model="data.CarbonData['CarbonData1']['hive.metastore.service.principal']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Hive元存储服务的Kerberos主体。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.metastore.client.principal:" prop="hive.metastore.client.principal">
                  <el-input class="inputWidth"
                            v-model="data.CarbonData['CarbonData1']['hive.metastore.client.principal']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      openLooKeng在连接到Hive元存储服务时将使用的Kerberos主体。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.metastore.client.keytab:" prop="hive.metastore.client.keytab">
                  <el-input class="inputWidth"
                            v-model="data.CarbonData['CarbonData1']['hive.metastore.client.keytab']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Hive元存储客户端keytab位置。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.config.resources:" prop="hive.config.resources">
                  <el-input class="inputWidth"
                            v-model="data.CarbonData['CarbonData1']['hive.config.resources']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      使用联邦HDFS或NameNode高可用性时，需要指定额外的HDFS客户端选项，以便访问HDFS集群。
                      <br/>要指定选项，添加hive.config.resources属性来引用HDFS配置文件
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="-DHADOOP_USER_NAME:" prop="-DHADOOP_USER_NAME">
                  <el-input class="inputWidth"
                            v-model="data.CarbonData['CarbonData1']['-DHADOOP_USER_NAME']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      如果openLooKeng作为nobody运行，则openLooKeng将作为nobody访问HDFS。
                      <br/>可以通过在openLooKeng JVM配置中设置HADOOP_USER_NAME系统属性来覆盖此用户名
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="carbondata.store-location:" prop="carbondata.store-location">
                  <el-input class="inputWidth"
                            v-model="data.CarbonData['CarbonData1']['carbondata.store-location']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      CarbonData仓库的存储位置。如果不指定，则使用默认的Hive仓库路径，
                      <br/>即 /user/hive/warehouse/carbon.store
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="carbondata.minor-vacuum-seg-count:" prop="carbondata.minor-vacuum-seg-count">
                  <el-input class="inputWidth"
                            v-model="data.CarbonData['CarbonData1']['carbondata.minor-vacuum-seg-count']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      指定可考虑对Carbondata表进行Minor Vacuum的段数。
                      <br/>如果未指定或设置为小于2的数，则考虑所有可用段。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="carbondata.major-vacuum-seg-size:" prop="carbondata.major-vacuum-seg-size">
                  <el-input class="inputWidth"
                            v-model="data.CarbonData['CarbonData1']['carbondata.major-vacuum-seg-size']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      指定对Carbondata表进行Major Vacuum的大小限制，单位为GB。
                      <br/>累计大小小于此阈值的所有段都将纳入考虑范围。
                      <br/>如果未指定，则使用默认清空值，即1GB。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.metastore:" prop="hive.metastore">
                  <el-input class="inputWidth"
                            v-model="data.CarbonData['CarbonData1']['hive.metastore']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      要使用的Hive元存储的类型。openLooKeng目前支持默认的Hive Thrift元存储（thrift）。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.config.resources:" prop="hive.config.resources">
                  <el-input class="inputWidth"
                            v-model="data.CarbonData['CarbonData1']['hive.config.resources']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      以逗号分隔的HDFS配置文件列表。这些文件必须存在于运行openLooKeng的机器上。
                      <br/>示例：/etc/hdfs-site.xml
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.hdfs.authentication.type:" prop="hive.hdfs.authentication.type">
                  <el-input class="inputWidth"
                            v-model="data.CarbonData['CarbonData1']['hive.hdfs.authentication.type']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      HDFS身份验证类型。取值为NONE或KERBEROS。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.hdfs.impersonation.enabled:" prop="hive.hdfs.impersonation.enabled">
                  <el-switch v-model="data.common['common1']['hive.hdfs.impersonation.enabled:']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      启用HDFS端用户模拟。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.hdfs.presto.principal:" prop="hive.hdfs.presto.principal">
                  <el-input class="inputWidth"
                            v-model="data.CarbonData['CarbonData1']['hive.hdfs.presto.principal']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      openLooKeng在连接到HDFS时将使用的Kerberos主体。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.hdfs.presto.keytab:" prop="hive.hdfs.presto.keytab">
                  <el-input class="inputWidth"
                            v-model="data.CarbonData['CarbonData1']['hive.hdfs.presto.keytab']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      HDFS客户端keytab位置。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.collect-column-statistics-on-write:"
                              prop="hive.collect-column-statistics-on-write">
                  <el-switch v-model="data.common['common1']['hive.collect-column-statistics-on-write:']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      启用写入时自动收集列级统计信息。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="carbondata.vacuum-service-threads:" prop="carbondata.vacuum-service-threads">
                  <el-input class="inputWidth"
                            v-model="data.CarbonData['CarbonData1']['carbondata.vacuum-service-threads']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      指定自动清理的线程数。最小值为1。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="carbondata.auto-vacuum-enabled:" prop="carbondata.auto-vacuum-enabled">
                  <el-switch v-model="data.common['common1']['carbondata.auto-vacuum-enabled:']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      对CarbonData表启用自动清理。
                      <br/>如需在引擎侧启用自动清理，请在协调节点的config.properties中添加auto-vacuum.enabled=true。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>


              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('CarbonData')">提交</el-button>
          </el-row>

        </el-tab-pane>
        <el-tab-pane label="ClickHouse连接器" name="ClickHouse">
          <el-tabs v-model="data.ClickHouse.ClickHouseTabsValue" type="card" editable
                   @edit="handleTabsEdit">
            <el-tab-pane
              :key="item.name"
              v-for="item in data.ClickHouse.ClickHouseTabs"
              :label="item.title"
              :name="item.name"
            >

              <el-form label-width="260px" class="demo-ruleForm">

                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.ClickHouse['ClickHouse'+item.configGroup]['connector.name']"></el-input>
                </el-form-item>

                <el-form-item label="connection-url:">
                  <el-input class="inputWidth"
                            v-model="data.ClickHouse['ClickHouse'+item.configGroup]['connection-url']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      需要连接的openLooKeng的URL
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="connection-user:">
                  <el-input class="inputWidth"
                            v-model="data.ClickHouse['ClickHouse'+item.configGroup]['connection-user']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      需要连接的openLooKeng的用户名
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="connection-password:">
                  <el-input class="inputWidth"
                            v-model="data.ClickHouse['ClickHouse'+item.configGroup]['connection-password']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      需要连接的openLooKeng的密码
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="allow-drop-table:">
                  <el-switch
                    v-model="data.ClickHouse['ClickHouse'+item.configGroup]['allow-drop-table']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      是否允许连接器删除表
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="clickhouse.query.pushdown.enabled:">
                  <el-switch
                    v-model="data.ClickHouse['ClickHouse'+item.configGroup]['clickhouse.query.pushdown.enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      是否开启查询下推功能,连接器的下推功能默认打开
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="case-insensitive-name-matching:">
                  <el-switch
                    v-model="data.ClickHouse['ClickHouse'+item.configGroup]['case-insensitive-name-matching']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      是否区分表名大小写
                      <br/>与openLooKeng不同，ClickHouse的语法是大小写敏感的，如果您的数据库表中存在大写字段，可以设置.
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('ClickHouse')">提交</el-button>
          </el-row>

        </el-tab-pane>


        <el-tab-pane label="数据中心连接器" name="dataCenter">
          <el-tabs v-model="data.dataCenter.dataCenterTabsValue" type="card" editable
                   @edit="handleTabsEdit">
            <el-tab-pane
              :key="item.name"
              v-for="item in data.dataCenter.dataCenterTabs"
              :label="item.title"
              :name="item.name"
            >
              <el-form label-width="320px" class="demo-ruleForm">
                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['connector.name']"></el-input>
                </el-form-item>

                <el-form-item label="connection-url:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['connection-url']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      需要连接的openLooKeng的URL
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="connection-user:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['connection-user']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      需要连接的openLooKeng的用户名
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="connection-password:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['connection-password']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      需要连接的openLooKeng的密码
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.kerberos.config.path:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.kerberos.config.path']"></el-input>
                  <i class="el-icon-upload"></i>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Kerberos配置文件
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.kerberos.credential.cachepath:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.kerberos.credential.cachepath']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Kerberos凭证缓存
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.kerberos.keytab.path:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.kerberos.keytab.path']"></el-input>
                  <i class="el-icon-upload"></i>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Kerberos keytab文件
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.kerberos.principal:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.kerberos.principal']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      向openLooKeng协调节点进行身份验证时使用的主体
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.kerberos.remote.service.name:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.kerberos.remote.service.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      openLooKeng协调节点Kerberos服务的名称。Kerberos身份验证时，需要配置该参数
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.kerberos.service.principal.pattern:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.kerberos.service.principal.pattern']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      openLooKeng协调节点Kerberos服务主体模式
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.kerberos.use.canonical.hostname:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.kerberos.use.canonical.hostname']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      通过首先将主机名解析为IP地址，然后对该IP地址执行反向DNS查找，从而使用Kerberos服务主体的openLooKeng协调节点的规范主机名
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.accesstoken:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.accesstoken']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      基于令牌身份验证的访问令牌
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.extra.credentials:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.extra.credentials']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      连接外部服务的额外凭证。ExtraCredentials是一个键值对列表。
                      <br/>示例：foo:bar;abc:xyz将创建凭证abc=xyz和foo=bar。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.ssl:">
                  <el-switch
                    v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.ssl']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      使用HTTPS连接
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.ssl.keystore.password:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.ssl.keystore.password']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      keystore密码
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.ssl.keystore.path:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.ssl.keystore.path']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      包含用于身份验证的证书和私钥的JavaKeyStore文件的位置
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.ssl.keystore.password:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.ssl.keystore.password']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      keystore密码
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.ssl.truststore.path:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.ssl.truststore.path']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      用于验证HTTPS服务器证书的Java TrustStore文件的位置
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.socksproxy:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.socksproxy']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      SOCKS代理主机和端口。示例：localhost:1080
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.httpproxy:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.httpproxy']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      HTTP代理主机和端口。示例：localhost:8888
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.metadata.cache.enabled:">
                  <el-switch
                    v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.metadata.cache.enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      启用元数据缓存，缓存远端openLooKeng的元数据信息
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.metadata.cache.maximum.size:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.metadata.cache.maximum.size']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      元数据缓存最大值，可缓存的远端openLooKeng元数据条数
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.metadata.cache.ttl:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.metadata.cache.ttl']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      元数据缓存TTL，TTL到期，则需要重新从远端openLooKeng获取元数据
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.query.pushdown.enabled:">
                  <el-switch
                    v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.query.pushdown.enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      启用子查询下推到远端openLooKeng
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.query.pushdown.module:">
                  <el-select v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.query.pushdown.module']"
                             placeholder="请选择">
                    <el-option label="FULL_PUSHDOWN" value='FULL_PUSHDOWN'></el-option>
                    <el-option label="BASE_PUSHDOWN" value="BASE_PUSHDOWN"></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      FULL_PUSHDOWN，表示全部下推；BASE_PUSHDOWN，表示部分下推，
                      <br/>其中部分下推是指filter/aggregation/limit/topN/project这些可以下推。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.http-compression:">
                  <el-switch
                    v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.http-compression']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      启用zstd压缩数据
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.http-request-connectTimeout:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.http-request-connectTimeout']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      HTTP请求连接超时，默认值为30秒
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.http-request-readTimeout:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.http-request-readTimeout']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      HTTP请求读取超时，默认为30秒
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.httpclient.maximum.idle.connections:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.httpclient.maximum.idle.connections']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      HTTP客户端保持打开的最大空闲连接
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.http-client-timeout:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.http-client-timeout']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      客户端持续重试取数据的时间，默认值为10分钟
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.max.anticipated.delay:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.max.anticipated.delay']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      集群中两个查询请求之间的最大预期时延。如果远程dc没有收到超过此延迟的请求，则可能会取消查询
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.application.name.prefix:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.application.name.prefix']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      添加到任何指定的ApplicationName客户端信息属性的前缀，该前缀用于设置openLooKeng查询的源名称。如果没有设置此属性或ApplicationName，
                      <br/>则查询的源将是hetu-dc
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.remote-http-server.max-request-header-size:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.remote-http-server.max-request-header-size']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      此属性应等效于远程服务器中http-server.max-request-header-size的值
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dc.remote.cluster.id:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dc.remote.cluster.id']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      远程集群的唯一ID
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.data.center.split.count:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['hetu.data.center.split.count']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      每个查询允许的最大Split个数
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.data.center.consumer.timeout:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['hetu.data.center.consumer.timeout']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      执行查询获取到数据后，等待被取走的最大时延
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="enable-dynamic-filtering:">
                  <el-switch
                    v-model="data.dataCenter['dataCenter'+item.configGroup]['enable-dynamic-filtering']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      是否启用动态过滤特性
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dynamic-filtering-max-per-driver-row-count:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dynamic-filtering-max-per-driver-row-count']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      每个driver最大允许处理的行数，超过该行数，则该查询的动态过滤特性会自动取消
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dynamic-filtering-max-per-driver-size:">
                  <el-input class="inputWidth"
                            v-model="data.dataCenter['dataCenter'+item.configGroup]['dynamic-filtering-max-per-driver-size']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      每个driver最大允许处理的数据量大小，超过该值，则该查询的动态过滤特性会自动取消
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>
              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('dataCenter')">提交</el-button>
          </el-row>

        </el-tab-pane>


        <el-tab-pane label="Elasticsearch连接器" name="Elasticsearch">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="连接器1" name="1">
              <el-form label-width="270px" class="demo-ruleForm">
                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['connector.name']"></el-input>
                </el-form-item>

                <el-form-item label="elasticsearch.host:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['elasticsearch.host']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      定义连接Elasticsearch节点的主机。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="elasticsearch.port:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['elasticsearch.port']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      定义连接Elasticsearch节点的端口号。
                      <br/>此属性是可选的；默认值为9200。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="elasticsearch.default-schema-name:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['elasticsearch.default-schema-name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      定义将包含没有限定模式名称的所有表的模式。
                      <br/>此属性是可选的；默认值为default。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="elasticsearch.scroll-size:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['elasticsearch.scroll-size']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      此属性定义每个Elasticsearch滚动请求中可以返回的最大命中数。
                      <br/>此属性是可选的；默认值为1000。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="elasticsearch.scroll-timeout:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['elasticsearch.scroll-timeout']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      此属性定义了Elasticsearch将保持滚动请求的时间量（毫秒）。
                      <br/>此属性是可选的；默认值为1m。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="elasticsearch.request-timeout:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['elasticsearch.scroll-timeout']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      此属性定义了Elasticsearch将保持滚动请求的时间量（毫秒）。
                      <br/>此属性是可选的；默认值为1m。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="elasticsearch.request-timeout:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['elasticsearch.request-timeout']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      此属性定义所有Elasticsearch请求的超时值。
                      <br/>此属性是可选的；默认值为10s。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="elasticsearch.connect-timeout:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['elasticsearch.connect-timeout']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      此属性定义了所有连接Elasticsearch的超时值。
                      <br/>此属性是可选的；默认值为1s。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="elasticsearch.max-retry-time:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['elasticsearch.max-retry-time']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      此属性定义了单个连接的最大重试时间。
                      <br/>此属性是可选的；默认值为20s。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="elasticsearch.node-refresh-interval:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['elasticsearch.node-refresh-interval']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      此属性定义了可用Elasticsearch节点更新频率。
                      <br/>此属性是可选的；默认值为1m。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="elasticsearch.security:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['elasticsearch.security']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      配置连接Elasticsearch的认证类型。目前仅支持PASSWORD。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="elasticsearch.auth.user:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['elasticsearch.auth.user']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      连接Elasticsearch认证的用户名。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="elasticsearch.auth.password:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['elasticsearch.auth.password']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      连接Elasticsearch认证的密码。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="elasticsearch.tls.keystore-path:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['elasticsearch.tls.keystore-path']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      此属性定义了PEM或JKS格式的key store文件的路径, 该文件必须可由运行openLooKeng的操作系统用户读取。
                      <br/>此属性是可选的。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="elasticsearch.tls.truststore-path:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['elasticsearch.tls.truststore-path']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      此属性定义了PEM或JKS格式的trust store文件的路径, 该文件必须可由运行openLooKeng的操作系统用户读取。。
                      <br/>此属性是可选的。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="elasticsearch.tls.keystore-password:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['elasticsearch.tls.keystore-password']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      此属性定义了key store文件的密码。
                      <br/>此属性是可选的。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="elasticsearch.tls.truststore-password:">
                  <el-input class="inputWidth"
                            v-model="data.Elasticsearch['Elasticsearch1']['elasticsearch.tls.truststore-password']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      此属性定义了trust store文件的密码。
                      <br/>此属性是可选的。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('Elasticsearch')">提交</el-button>
          </el-row>

        </el-tab-pane>

        <el-tab-pane label="Greenplum连接器" name="Greenplum">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="连接器1" name="1">
              <el-form label-width="270px" class="demo-ruleForm">

                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.Greenplum['Greenplum1']['connector.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="connection-url:">
                  <el-input class="inputWidth"
                            v-model="data.Greenplum['Greenplum1']['connection-url']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      主机
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="connection-user:">
                  <el-input class="inputWidth"
                            v-model="data.Greenplum['Greenplum1']['connection-user']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      用户
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="connection-password:">
                  <el-input class="inputWidth"
                            v-model="data.Greenplum['Greenplum1']['connection-password']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      密码
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="greenplum.allow-modify-table:">
                  <el-switch
                    v-model="data.Greenplum['Greenplum1']['greenplum.allow-modify-table']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      我们可以在greenplum.properties中设置greenplum.allow-modify-table来声明是否允许Greenplum connector修改数据源SQL表格。
                      <br/>如果 greenplum.allow-modify-table 被设置成 false, create/rename/add column/rename column/drop
                      column等操作都不能执行。
                      <br/>默认设置为true。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="jdbc.pushdown-enabled:">
                  <el-switch
                    v-model="data.Greenplum['Greenplum1']['jdbc.pushdown-enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      我们在greenplum.properties中配置jdbc.pushdown-enabled配置项来启动或者关闭这个特性。
                      <br/>如果jdbc.pushdown-enabled设置成 false, Query Push Down特性被关闭。
                      <br/>如果jdbc.pushdown-enabled设置成 true, Query Push Down特性被打开。 Query Push Down特性默认打开。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="jdbc.pushdown-module:" prop="jdbc.pushdown-module">
                  <el-select v-model="data.Greenplum['Greenplum1']['jdbc.pushdown-module']" placeholder="请选择">
                    <el-option label="BASE_PUSHDOWN" value='BASE_PUSHDOWN'></el-option>
                    <el-option label="FULL_PUSHDOWN" value="FULL_PUSHDOWN"></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Query Push Down特性的模式选择 我们可以通过在greenplum.properties中配置jdbc.pushdown-module配置项来选择下推模式。
                      <br/>默认来说，我们系统使用的模式是BASE_PUSHDOWN. 你也可以设置成FULL_PUSHDOWN。
                      <br/>两个模式的不同之处在于：FULL_PUSHDOWN: 所有Query Push Down支持的算子都下推。
                      <br/>BASE_PUSHDOWN: 只下推部分算子, 包括： filter, aggregation, limit, topN and project等。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>
              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('Greenplum')">提交</el-button>
          </el-row>

        </el-tab-pane>

        <el-tab-pane label="Hana连接器" name="Hana">
          <el-tabs v-model="data.Hana.HanaTabsValue" type="card" editable
                   @edit="handleTabsEdit">
            <el-tab-pane
              :key="item.name"
              v-for="item in data.Hana.HanaTabs"
              :label="item.title"
              :name="item.name"
            >
              <el-form label-width="320px" class="demo-ruleForm">

                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.Hana['Hana'+item.configGroup]['connector.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="connection-url:">
                  <el-input class="inputWidth"
                            v-model="data.Hana['Hana'+item.configGroup]['connection-url']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      主机:端口
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="connection-user:">
                  <el-input class="inputWidth"
                            v-model="data.Hana['Hana'+item.configGroup]['connection-user']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      用户名
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="connection-password:">
                  <el-input class="inputWidth"
                            v-model="data.Hana['Hana'+item.configGroup]['connection-password']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      密码
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="allow-drop-table:">
                  <el-switch
                    v-model="data.Hana['Hana'+item.configGroup]['allow-drop-table']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      是否允许hana连接器丢弃表
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="jdbc.pushdown-enabled:">
                  <el-switch
                    v-model="data.Hana['Hana'+item.configGroup]['jdbc.pushdown-enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      如果要启用hana连接器的连接器下推功能，不需要做任何操作，hana连接器的下推功能默认是打开的。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="jdbc.pushdown-module:" prop="jdbc.pushdown-module">
                  <el-select v-model="data.Hana['Hana'+item.configGroup]['jdbc.pushdown-module']" placeholder="请选择">
                    <el-option label="FULL_PUSHDOWN" value='FULL_PUSHDOWN'></el-option>
                    <el-option label="BASE_PUSHDOWN" value="BASE_PUSHDOWN"></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      如果要启用hana连接器的全部下推功能，不需要做任何操作，hana连接器的下推模式默认是全部下推的。
                      <br/>#FULL_PUSHDOWN，表示全部下推；BASE_PUSHDOWN，表示部分下推，其中部分下推是指filter/aggregation/limit/topN/project这些可以下推。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('Hana')">提交</el-button>
          </el-row>

        </el-tab-pane>


        <el-tab-pane label="HBase连接器" name="HBase">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="连接器1" name="1">
              <el-form label-width="270px" class="demo-ruleForm">

                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.HBase['HBase1']['connector.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      connector.name是固定的
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.zookeeper.quorum:">
                  <el-input class="inputWidth"
                            v-model="data.HBase['HBase1']['hbase.zookeeper.quorum']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      ZooKeeper集群地址
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.zookeeper.property.clientPort:">
                  <el-input class="inputWidth"
                            v-model="data.HBase['HBase1']['hbase.zookeeper.property.clientPort']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Zookeeper客户端端口
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.zookeeper.znode.parent:">
                  <el-input class="inputWidth"
                            v-model="data.HBase['HBase1']['hbase.zookeeper.znode.parent']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      HBase的Zookeeper根节点路径
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.client.retries.number:">
                  <el-input class="inputWidth"
                            v-model="data.HBase['HBase1']['hbase.client.retries.number']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      HBase客户端连接重试次数
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.client.pause.time:">
                  <el-input class="inputWidth"
                            v-model="data.HBase['HBase1']['hbase.client.pause.time']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      HBase客户端断连时间
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.rpc.protection.enable:" prop="hbase.rpc.protection.enable">
                  <el-switch v-model="data.HBase['HBase1']['hbase.rpc.protection.enable']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      通信隐私保护。可以从hbase-site.xml获取该属性的值
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.default.value:">
                  <el-input class="inputWidth"
                            v-model="data.HBase['HBase1']['hbase.default.value']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      表中数据的默认值
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.metastore.type:">
                  <el-input class="inputWidth"
                            v-model="data.HBase['HBase1']['hbase.metastore.type']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      HBase元数据的存储，hetuMetastore
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.authentication.type:">
                  <el-input class="inputWidth"
                            v-model="data.HBase['HBase1']['hbase.authentication.type']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      HDFS/HBase组件访问安全身份验证方式
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.kerberos.principal:">
                  <el-input class="inputWidth"
                            v-model="data.HBase['HBase1']['hbase.kerberos.principal']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      安全身份验证的用户名
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.kerberos.keytab:">
                  <el-input class="inputWidth"
                            v-model="data.HBase['HBase1']['hbase.kerberos.keytab']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      安全身份验证的密钥
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.client.side.enable:" prop="hbase.client.side.enable">
                  <el-switch v-model="data.HBase['HBase1']['hbase.client.side.enable']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      以clientSide模式访问数据，根据hdfs上的快照，获取region上的数据
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.hbase.site.path:">
                  <el-input class="inputWidth"
                            v-model="data.HBase['HBase1']['hbase.hbase.site.path']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      连接安全HBase集群的配置
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.client.side.snapshot.retry:">
                  <el-input class="inputWidth"
                            v-model="data.HBase['HBase1']['hbase.client.side.snapshot.retry']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      HBase客户端创建snapshot的重试次数
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.hdfs.site.path:">
                  <el-input class="inputWidth"
                            v-model="data.HBase['HBase1']['hbase.hdfs.site.path']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      配置ClientSide模式时，连接HDFS集群的配置hdfs-site.xml的路径
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.core.site.path:">
                  <el-input class="inputWidth"
                            v-model="data.HBase['HBase1']['hbase.core.site.path']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      配置ClientSide模式时，连接HDFS集群的配置core-site.xml的路径
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.jaas.conf.path:">
                  <el-input class="inputWidth"
                            v-model="data.HBase['HBase1']['hbase.jaas.conf.path']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      安全身份验证的JAAS
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hbase.krb5.conf.path:">
                  <el-input class="inputWidth"
                            v-model="data.HBase['HBase1']['hbase.krb5.conf.path']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      安全身份验证的krb5
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('HBase')">提交</el-button>
          </el-row>

        </el-tab-pane>


        <el-tab-pane label="Hive连接器" name="Hive">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="连接器1" name="1">
              <el-form label-width="270px" class="demo-ruleForm">

                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['connector.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.metastore.uri:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.metastore.uri']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.config.resources:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.config.resources']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      以逗号分隔的可选HDFS配置文件列表。
                      <br/>这些文件必须存在于运行openLooKeng的机器上。
                      <br/>该属性仅在访问HDFS绝对必要的情况下指定。示例：/etc/hdfs-site.xml
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="-DHADOOP_USER_NAME:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['-DHADOOP_USER_NAME']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      在不使用带HDFS的Kerberos时，openLooKeng会使用openLooKeng进程的操作系统用户来访问HDFS。
                      <br/>例如，如果openLooKeng作为nobody运行，则openLooKeng将作为nobody访问HDFS。
                      <br/>可以通过在openLooKeng JVM配置中设置HADOOP_USER_NAME系统属性来覆盖此用户名，用适当的用户名替换hdfs_user：
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.metastore:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.metastore']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Hive元存储类型
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.recursive-directories:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.recursive-directories']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      允许从表或分区位置的子目录读取数据。如果禁用，子目录将被忽略。
                      <br/>这相当于Hive中的hive.mapred.supports.subdirectories属性。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.storage-format:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.storage-format']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      创建新表时使用的默认文件格式。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.compression-codec:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.compression-codec']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      写入文件时使用的压缩编解码器。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.force-local-scheduling:" prop="hive.force-local-scheduling">
                  <el-switch v-model="data.Hive['Hive1']['hive.force-local-scheduling']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      强制将分片调度到与分片数据的Hadoop DataNode进程同一节点。
                      <br/>这对于openLooKeng与每个DataNode并置的安装非常有用。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.respect-table-format:" prop="hive.respect-table-format">
                  <el-switch v-model="data.Hive['Hive1']['hive.respect-table-format']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      应该使用现有的表格式还是默认的openLooKeng格式写入新的分区？
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.immutable-partitions:" prop="hive.immutable-partitions">
                  <el-switch v-model="data.Hive['Hive1']['hive.immutable-partitions']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      新数据是否可以插入到现有分区中？
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.create-empty-bucket-files:" prop="hive.create-empty-bucket-files">
                  <el-switch v-model="data.Hive['Hive1']['hive.create-empty-bucket-files']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      对于没有数据的桶，是否应该创建空文件？
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.max-partitions-per-writers:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.max-partitions-per-writers']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      每个写入进程最大分区数。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.max-partitions-per-scan:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.max-partitions-per-scan']"></el-input>
                  <i class="el-icon-upload"></i>
                  <el-tooltip placement="top">
                    <div slot="content">
                      单表扫描最大分区数。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.hdfs.authentication.type:">
                  <el-select v-model="data.Hive['Hive1']['hive.hdfs.authentication.type']" placeholder="请选择">
                    <el-option label="NONE" value='NONE'></el-option>
                    <el-option label="KERBEROS" value="KERBEROS"></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      HDFS身份验证类型。取值为NONE或KERBEROS。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.hdfs.impersonation.enabled:" prop="hive.hdfs.impersonation.enabled">
                  <el-switch v-model="data.Hive['Hive1']['hive.hdfs.impersonation.enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      启用HDFS端用户模拟。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.hdfs.presto.principal:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.hdfs.presto.principal']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      openLooKeng在连接到HDFS时将使用的Kerberos主体。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.hdfs.presto.keytab:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.hdfs.presto.keytab']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      HDFS客户端keytab位置。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.security:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.security']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      参见Hive安全配置。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="security.config-file:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['security.config-file']"></el-input>
                  <i class="el-icon-upload"></i>
                  <el-tooltip placement="top">
                    <div slot="content">
                      hive.security=file时使用的配置文件的路径。有关详细信息，请参阅基于文件的授权。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.non-managed-table-writes-enabled:" prop="hive.non-managed-table-writes-enabled">
                  <el-switch v-model="data.Hive['Hive1']['hive.non-managed-table-writes-enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      允许对非托管（外部）Hive表的写入。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.non-managed-table-creates-enabled:" prop="hive.non-managed-table-creates-enabled">
                  <el-switch v-model="data.Hive['Hive1']['hive.non-managed-table-creates-enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      允许创建非托管（外部）Hive表。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.collect-column-statistics-on-write:" prop="hive.collect-column-statistics-on-write">
                  <el-switch v-model="data.Hive['Hive1']['hive.collect-column-statistics-on-write']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      启用写入时自动收集列级统计信息。详见表统计信息。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.s3select-pushdown.enabled:" prop="hive.s3select-pushdown.enabled">
                  <el-switch v-model="data.Hive['Hive1']['hive.s3select-pushdown.enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      允许向AWS S3 Select服务的查询下推。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.s3select-pushdown.max-connections:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.s3select-pushdown.max-connections']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      S3 Select下推同时打开到S3的最大连接数。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.orc.use-column-names:" prop="hive.orc.use-column-names">
                  <el-switch v-model="data.Hive['Hive1']['hive.orc.use-column-names']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      为了支持alter表drop列，建议在Hive属性中添加hive.orc.use-column-names=true，否则drop列可能无法正常工作。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.orc-predicate-pushdown-enabled:" prop="hive.orc-predicate-pushdown-enabled">
                  <el-switch v-model="data.Hive['Hive1']['hive.orc-predicate-pushdown-enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      在读取ORC文件时启用算子下推（predicates pushdown）处理。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.orc.time-zone:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.orc.time-zone']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      为未声明时区的旧ORC文件设置默认时区。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.parquet.time-zone:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.parquet.time-zone']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      将时间戳值调整到特定的时区。对于Hive 3.1+，该值应设置为UTC。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.rcfile.time-zone:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.rcfile.time-zone']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      将二进制编码的时间戳值调整到特定的时区。对于Hive 3.1+，该值应设置为UTC。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.vacuum-service-threads:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.vacuum-service-threads']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      清空服务中运行的线程数。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.auto-vacuum-enabled:" prop="hive.auto-vacuum-enabled">
                  <el-switch v-model="data.Hive['Hive1']['hive.auto-vacuum-enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      对Hive表启用自动清空功能。要在引擎侧启用自动清空，请在协调节点的config.properties中添加auto-vacuum.enabled=true。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.vacuum-delta-num-threshold:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.vacuum-delta-num-threshold']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      允许不压缩的增量目录的最大数量。最小值为2。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.vacuum-delta-percent-threshold:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.vacuum-delta-percent-threshold']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      允许不压缩的增量目录的最大百分比。值应在0.1到1.0之间。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.vacuum-cleanup-recheck-interval:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.vacuum-cleanup-recheck-interval']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      清空清理任务重新提交的间隔。最小值为5分钟
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.vacuum-collector-interval:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.vacuum-collector-interval']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      清空回收器任务重新提交的间隔。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.max-splits-to-group:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.max-splits-to-group']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      可分组的最大拆分数。如果值为1，则不分组。最小值为1。
                      <br/>小的拆分越多，创建的驱动越多，因此需要更多内存、调度、上下文切换，这会影响读取性能。
                      <br/>将小拆分分组在一起可以减少拆分和创建驱动的数量，因此需要的资源较少，从而提高性能。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.metastore-client-service-threads:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.metastore-client-service-threads']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      元存储客户端与Hive元存储通信的并行线程数。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.worker-metastore-cache-enabled:" prop="hive.worker-metastore-cache-enabled">
                  <el-switch v-model="data.Hive['Hive1']['hive.worker-metastore-cache-enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      在工作节点上也开启对Hive元存储的缓存。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.metastore-write-batch-size:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.metastore-write-batch-size']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      每个请求中发送到元存储的分区数。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.metastore-cache-ttl:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.metastore-cache-ttl']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      表和分区元数据的元存储缓存淘汰时间。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.metastore-refresh-interval:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.metastore-refresh-interval']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      从Hive元存储刷新表和分区元数据的元存储缓存条目的时间。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.metastore-db-cache-ttl:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.metastore-db-cache-ttl']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      数据库、角色、配置、表和视图列表对象的元存储缓存淘汰时间。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.metastore-db-refresh-interval:">
                  <el-input class="inputWidth"
                            v-model="data.Hive['Hive1']['hive.metastore-db-refresh-interval']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      从Hive元存储中刷新数据库、表列表、视图列表、角色对象的元存储缓存条目的时间。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('Hive')">提交</el-button>
          </el-row>

        </el-tab-pane>


        <el-tab-pane label="Hudi连接器" name="Hudi">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="连接器1" name="1">
              <el-form label-width="270px" class="demo-ruleForm">

                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.Hudi['Hudi1']['connector.name']"></el-input>
                </el-form-item>

                <el-form-item label="hive.metastore.uri:">
                  <el-input class="inputWidth"
                            v-model="data.Hudi['Hudi1']['hive.metastore.uri']"></el-input>
                </el-form-item>
              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('Hudi')">提交</el-button>
          </el-row>

        </el-tab-pane>


        <el-tab-pane label="JMX连接器" name="JMX">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="连接器1" name="1">
              <el-form label-width="270px" class="demo-ruleForm">

                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.JMX['JMX1']['connector.name']"></el-input>
                </el-form-item>

                <el-form-item label="jmx.dump-tables:">
                  <el-input class="inputWidth"
                            v-model="data.JMX['JMX1']['jmx.dump-tables']"></el-input>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('JMX')">提交</el-button>
          </el-row>

        </el-tab-pane>

        <el-tab-pane label="Kafka连接器" name="Kafka">
          <el-tabs v-model="data.Kafka.KafkaTabsValue" type="card" editable @edit="handleTabsEdit">
            <el-tab-pane
              :key="item.name"
              v-for="item in data.Kafka.KafkaTabs"
              :label="item.title"
              :name="item.name"
            >
              <el-form label-width="270px" class="demo-ruleForm">

                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.Kafka['Kafka'+item.configGroup]['connector.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="kafka.table-names:">
                  <el-input class="inputWidth"
                            v-model="data.Kafka['Kafka'+item.configGroup]['kafka.table-names']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      此目录提供的所有表的逗号分隔列表。表名可以是非限定的（简单名称），
                      <br/>并将被放入默认模式（见下文）中，或者用模式名称（schema-name.table-name）限定。
                      <br/>对于这里定义的每个表，都可能存在一个表描述文件（见下文）。
                      <br/>如果没有表描述文件，则使用表名作为Kafka的主题名称，且数据列不映射到表。该表仍将包含所有内部列（见下文）。
                      <br/>此属性是必需的；没有默认值，并且必须至少定义一个表
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="kafka.default-schema:">
                  <el-input class="inputWidth"
                            v-model="data.Kafka['Kafka'+item.configGroup]['kafka.default-schema']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      定义将包含没有定义限定模式名称的所有表的模式。
                      <br/>此属性是可选的；默认值为default。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="kafka.nodes:">
                  <el-input class="inputWidth"
                            v-model="data.Kafka['Kafka'+item.configGroup]['kafka.nodes']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Kafka数据节点的hostname:port对的逗号分隔列表。
                      <br/>此属性是必需的；没有默认值，并且必须至少定义一个表。
                      <br/>说明:openLooKeng必须仍然能够连接到群集的所有节点，即使这里只指定了子集，因为段文件可能只位于特定的节点上。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="kafka.connect-timeout:">
                  <el-input class="inputWidth"
                            v-model="data.Kafka['Kafka'+item.configGroup]['kafka.connect-timeout']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      连接数据节点超时。繁忙的Kafka集群在接受连接之前可能要花费一些时间；当看到由于超时而导致的查询失败时，增加该值是一种很好的策略。
                      <br/>此属性是可选的；默认值为10秒（10s）。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="kafka.buffer-size:">
                  <el-input class="inputWidth"
                            v-model="data.Kafka['Kafka'+item.configGroup]['kafka.buffer-size']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      从Kafka读取数据的内部数据缓冲区大小。数据缓冲区必须至少能够容纳一条消息，理想情况下可以容纳多条消息。
                      <br/>每个工作节点和数据节点分配一个数据缓冲区。 此属性是可选的；默认值为64kb。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="kafka.table-description-dir:">
                  <el-input class="inputWidth"
                            v-model="data.Kafka['Kafka'+item.configGroup]['kafka.table-description-dir']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      在openLooKeng部署中引用一个文件夹，其中包含一个或多个JSON文件（必须以.json结尾），其中包含表描述文件。
                      <br/>此属性是可选的；默认值为etc/kafka。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="kafka.hide-internal-columns:" prop="kafka.hide-internal-columns">
                  <el-switch v-model="data.Kafka['Kafka'+item.configGroup]['kafka.hide-internal-columns']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      除了在表描述文件中定义数据列外，连接器还为每个表维护许多附加列。如果这些列是隐藏的，它们仍然可以在查询中使用，
                      <br/>但是不会显示在DESCRIBE ,table-name或SELECT *中。
                      <br/>此属性是可选的；默认值为true。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('Kafka')">提交</el-button>
          </el-row>

        </el-tab-pane>

        <el-tab-pane label="本地文件连接器" name="localFile">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="连接器1" name="1">
              <el-form label-width="270px" class="demo-ruleForm">

                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.localFile['localFile1']['connector.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="presto-logs.http-request-log.location:">
                  <el-input class="inputWidth"
                            v-model="data.localFile['localFile1']['presto-logs.http-request-log.location']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      写入HTTP请求日志的目录或文件
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="presto-logs.http-request-log.pattern:">
                  <el-input class="inputWidth"
                            v-model="data.localFile['localFile1']['presto-logs.http-request-log.pattern']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      如果日志位置是一个目录，这个glob将用于匹配目录中的文件名。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('localFile')">提交</el-button>
          </el-row>

        </el-tab-pane>


        <el-tab-pane label="内存连接器" name="memory">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="连接器1" name="1">
              <el-form label-width="270px" class="demo-ruleForm">

                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['connector.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="memory.max-data-per-node:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['memory.max-data-per-node']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.type:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['hetu.metastore.type']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.hetufilesystem.profile-name">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['hetu.metastore.hetufilesystem.profile-name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.hetufilesystem.path">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['hetu.metastore.hetufilesystem.path']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.cache.type">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['hetu.metastore.cache.type']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="memory.spill-path:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['memory.spill-path']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      在磁盘上持久化数据的位置。优先使用位于SSD的路径
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.embedded-state-store.enabled:" prop="hetu.embedded-state-store.enabled">
                  <el-switch v-model="data.memory['memory1']['hetu.embedded-state-store.enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="state-store.type:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['state-store.type']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="state-store.name:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['state-store.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="state-store.cluster:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['state-store.cluster']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hazelcast.discovery.mode:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['hazelcast.discovery.mode']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hazelcast.discovery.port:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['hazelcast.discovery.port']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hazelcast.discovery.tcp-ip.seeds:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['hazelcast.discovery.tcp-ip.seeds']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      # 每个服务器的ip地址和hazelcast端口应该被声明在这里。
                      <br/># 格式：`hazelcast.discovery.tcp-ip.seeds=host1:port,host2:port`
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.type:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['hetu.metastore.type']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.hetufilesystem.profile-name:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['hetu.metastore.hetufilesystem.profile-name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.hetufilesystem.path:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['hetu.metastore.hetufilesystem.path']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.cache.type:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['hetu.metastore.cache.type']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="fs.client.type:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['fs.client.type']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hdfs.config.resources:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['hdfs.config.resources']"></el-input>
                  <i class="el-icon-upload"></i>
                  <el-tooltip placement="top">
                    <div slot="content">
                      # Path to hdfs resource files (e.g. core-site.xml, hdfs-site.xml)
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hdfs.authentication.type:">
                  <el-select v-model="data.memory['memory1']['hdfs.authentication.type']" placeholder="请选择">
                    <el-option label="KERBEROS" value='KERBEROS'></el-option>
                    <el-option label="NONE" value="NONE"></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      # hdfs authentication, accepted values: KERBEROS/NONE
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="memory.max-data-per-node:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['memory.max-data-per-node']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      每个节点的内存大小使用限制
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="memory.max-logical-part-size:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['memory.max-logical-part-size']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      每个逻辑分片(LogicalPart)的大小限制
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="memory.max-page-size:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['memory.max-page-size']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      每个Page的大小限制
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="memory.logical-part-processing-delay:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['memory.logical-part-processing-delay']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      表创建后建立索引和写入磁盘前的等待时间
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="memory.thread-pool-size:">
                  <el-input class="inputWidth"
                            v-model="data.memory['memory1']['memory.thread-pool-size']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      后台线程（排序，清理数据，写入磁盘等）使用的线程池大小
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('memory')">提交</el-button>
          </el-row>

        </el-tab-pane>

        <el-tab-pane label="MongoDB连接器" name="MongoDB">
          <el-tabs v-model="data.MongoDB.MongoDBTabsValue" type="card" editable @edit="handleTabsEdit">
            <el-tab-pane
              :key="item.name"
              v-for="item in data.MongoDB.MongoDBTabs"
              :label="item.title"
              :name="item.name"
            >
              <el-form label-width="270px" class="demo-ruleForm">

                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.MongoDB['MongoDB'+item.configGroup]['connector.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="mongodb.seeds:">
                  <el-input class="inputWidth"
                            v-model="data.MongoDB['MongoDB'+item.configGroup]['mongodb.seeds']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      同一副本集中所有mongod服务器列表，以逗号分隔 ，格式如hostname[:port]，或者同一个分片集群的mongos服务器列表。
                      <br/>如果不指定port，则使用27017端口。 此属性是必需的；没有默认值，并且至少必须定义一个seed。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="mongodb.schema-collection:">
                  <el-input class="inputWidth"
                            v-model="data.MongoDB['MongoDB'+item.configGroup]['mongodb.schema-collection']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      由于MongoDB是文档数据库，因此系统中没有固定的schema信息。因此，每个MongoDB数据库中的一个特殊集合应定义所有表的架构。
                      <br/>有关详细信息，请参阅表格定义部分。
                      <br/>在启动时，此连接器尝试猜测字段的类型，但可能与用户创建的集合可不匹配。
                      <br/>在这种情况下，需要手动修改它。CREATE TABLE和CREATE TABLE AS SELECT会为用户创建一个条目。 该属性是可选的；
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="mongodb.case-insensitive-name-matching:"
                              prop="mongodb.case-insensitive-name-matching">
                  <el-switch
                    v-model="data.MongoDB['MongoDB'+item.configGroup]['mongodb.case-insensitive-name-matching']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      不区分大小写匹配数据库和集合名称。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="mongodb.credentials:">
                  <el-input class="inputWidth"
                            v-model="data.MongoDB['MongoDB'+item.configGroup]['mongodb.credentials']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      以逗号分隔的username:password@collection认证列表。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="mongodb.min-connections-per-host:">
                  <el-input class="inputWidth"
                            v-model="data.MongoDB['MongoDB'+item.configGroup]['mongodb.min-connections-per-host']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      此MongoClient实例每个主机的最小连接数。这些连接在空闲时将保留在连接池中。
                      <br/>当这些连接空闲时，它们将保存在连接池中，并且随着时间的推移，连接池将确保至少包含这个最小数目的连接。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="mongodb.connections-per-host:">
                  <el-input class="inputWidth"
                            v-model="data.MongoDB['MongoDB'+item.configGroup]['mongodb.connections-per-host']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      此MongoClient实例每个主机允许的最大连接数。这些连接在空闲时将保留在连接池中。
                      <br/>一旦连接池资源耗尽，任何需要连接的操作都将阻塞等待可用连接。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="mongodb.max-wait-time:">
                  <el-input class="inputWidth"
                            v-model="data.MongoDB['MongoDB'+item.configGroup]['mongodb.max-wait-time']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      线程可以等待连接变为可用状态的最大等待时间（以毫秒为单位）。值0表示它不会等待。负值表示无限期地等待连接变为可用。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="mongodb.max-connection-idle-time:">
                  <el-input class="inputWidth"
                            v-model="data.MongoDB['MongoDB'+item.configGroup]['mongodb.max-connection-idle-time']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      池化连接的最大空闲时间
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="mongodb.connections-timeout:">
                  <el-input class="inputWidth"
                            v-model="data.MongoDB['MongoDB'+item.configGroup]['mongodb.connections-timeout']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      连接超时（以毫秒为单位）。值0表示没有超时。仅在建立新连接时使用。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="mongodb.socket-timeout:">
                  <el-input class="inputWidth"
                            v-model="data.MongoDB['MongoDB'+item.configGroup]['mongodb.socket-timeout']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      套接字超时（以毫秒为单位）。它用于I / O套接字读取和写入操作。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="mongodb.socket-keep-alive:" prop="mongodb.socket-keep-alive">
                  <el-switch
                    v-model="data.MongoDB['MongoDB'+item.configGroup]['mongodb.socket-keep-alive']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      此标志控制套接字保持活动功能，该功能通过防火墙保持连接活动。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="mongodb.ssl.enabled:" prop="mongodb.ssl.enabled">
                  <el-switch v-model="data.MongoDB['MongoDB'+item.configGroup]['mongodb.ssl.enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      此标志用于启用与MongoDB服务器的SSL连接。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="mongodb.read-preference:">
                  <el-select v-model="data.MongoDB['MongoDB'+item.configGroup]['mongodb.read-preference']"
                             placeholder="请选择">
                    <el-option label="PRIMARY" value='PRIMARY'></el-option>
                    <el-option label="PRIMARY_PREFERRED" value="PRIMARY_PREFERRED"></el-option>
                    <el-option label="SECONDARY" value='SECONDARY'></el-option>
                    <el-option label="SECONDARY_PREFERRED" value="SECONDARY_PREFERRED"></el-option>
                    <el-option label="NEAREST" value='NEAREST'></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      读偏好用于查询、映射还原、聚合和计数
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="mongodb.write-concern:">
                  <el-select v-model="data.MongoDB['MongoDB'+item.configGroup]['mongodb.write-concern']"
                             placeholder="请选择">
                    <el-option label="ACKNOWLEDGED" value='ACKNOWLEDGED'></el-option>
                    <el-option label="FSYNC_SAFE" value="FSYNC_SAFE"></el-option>
                    <el-option label="FSYNCED" value='FSYNCED'></el-option>
                    <el-option label="JOURNAL_SAFEY" value="JOURNAL_SAFEY"></el-option>
                    <el-option label="JOURNALED" value='JOURNALED'></el-option>
                    <el-option label="MAJORITY" value="MAJORITY"></el-option>
                    <el-option label="NORMAL" value='NORMAL'></el-option>
                    <el-option label="REPLICA_ACKNOWLEDGED" value="REPLICA_ACKNOWLEDGED"></el-option>
                    <el-option label="REPLICAS_SAFE" value='REPLICAS_SAFE'></el-option>
                    <el-option label="UNACKNOWLEDGED" value="UNACKNOWLEDGED"></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      写入策略
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="mongodb.required-replica-set:">
                  <el-input class="inputWidth"
                            v-model="data.MongoDB['MongoDB'+item.configGroup]['mongodb.required-replica-set']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      所需的副本集名称
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="mongodb.cursor-batch-size:">
                  <el-input class="inputWidth"
                            v-model="data.MongoDB['MongoDB'+item.configGroup]['mongodb.cursor-batch-size']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      限制一批中返回的元素数。游标通常会获取一批结果对象并将其存储在本地。 如果batchSize为0，将使用驱动程序的默认值。
                      <br/>如果batchSize为正，则其值表示检索到的每批对象的大小。可以对其进行调整以优化性能并限制数据传输。
                      <br/>如果batchSize为负，它将限制返回的对象数量，这些对象的数量在最大批处理大小限制内（通常为4MB），并且游标将被关闭。
                      <br/>例如，如果batchSize为-10，则服务器将最多返回10个文档，并尽可能多地返回4MB中可以容纳的文档，然后关闭游标。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('MongoDB')">提交</el-button>
          </el-row>

        </el-tab-pane>


        <el-tab-pane label="MySQL连接器" name="MySQL">
          <el-tabs v-model="data.MySQL.MySQLTabsValue" type="card" editable @edit="handleTabsEdit">
            <el-tab-pane
              :key="item.name"
              v-for="item in data.MySQL.MySQLTabs"
              :label="item.title"
              :name="item.name"
            >
              <el-form label-width="200px" class="demo-ruleForm">
                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                    v-model="data.MySQL['MySQL'+item.configGroup]['connector.name']"></el-input>
                </el-form-item>

                <el-form-item label="connection-url:">
                  <el-input class="inputWidth"
                    v-model="data.MySQL['MySQL'+item.configGroup]['connection-url']"></el-input>
                </el-form-item>

                <el-form-item label="connection-user:">
                  <el-input class="inputWidth"
                    v-model="data.MySQL['MySQL'+item.configGroup]['connection-user']"></el-input>
                </el-form-item>

                <el-form-item label="connection-password:">
                  <el-input class="inputWidth"
                    v-model="data.MySQL['MySQL'+item.configGroup]['connection-password']"></el-input>
                </el-form-item>

                <el-form-item label="jdbc.pushdown-enabled:" prop="jdbc.pushdown-enabled">
                  <el-switch v-model="data.MySQL['MySQL'+item.configGroup]['jdbc.pushdown-enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      是否开启查询下推功能 如果要启用mysql连接器的连接器下推功能，不需要做任何操作，mysql连接器的下推功能默认是打开的。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="jdbc.pushdown-module:">
                  <el-select v-model="data.MySQL['MySQL'+item.configGroup]['jdbc.pushdown-module']" placeholder="请选择">
                    <el-option label="FULL_PUSHDOWN" value='FULL_PUSHDOWN'></el-option>
                    <el-option label="BASE_PUSHDOWN" value="BASE_PUSHDOWN"></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      下推模式选择,mysql连接器的下推模式默认是部分下推的，如果要启用mysql连接器的全部下推功能
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="jdbc.pushdown.remotenamespace:">
                  <el-input class="inputWidth"
                    v-model="data.MySQL['MySQL'+item.configGroup]['jdbc.pushdown.remotenamespace']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      将外部函数下推到MySQL数据源执行。
                      <br/>配置支持下推的外部函数注册命名空间catalog.schema。可以声明自己支持多个函数命名空间中的函数，
                      <br/>在jdbc.pushdown.remotenamespace配置项中使用'|'分割既可。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('MySQL')">提交</el-button>
          </el-row>

        </el-tab-pane>


        <el-tab-pane label="OpenGauss连接器" name="openGauss">
          <el-tabs v-model="data.openGauss.openGaussTabsValue" type="card" editable @edit="handleTabsEdit">
            <el-tab-pane
              :key="item.name"
              v-for="item in data.openGauss.openGaussTabs"
              :label="item.title"
              :name="item.name"
            >
              <el-form label-width="200px" class="demo-ruleForm">

                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                    v-model="data.openGauss['openGauss'+item.configGroup]['connector.name']"></el-input>
                </el-form-item>

                <el-form-item label="connection-url:">
                  <el-input class="inputWidth"
                    v-model="data.openGauss['openGauss'+item.configGroup]['connection-url']"></el-input>
                </el-form-item>

                <el-form-item label="connection-user:">
                  <el-input class="inputWidth"
                    v-model="data.openGauss['openGauss'+item.configGroup]['connection-user']"></el-input>
                </el-form-item>

                <el-form-item label="connection-password:">
                  <el-input class="inputWidth"
                    v-model="data.openGauss['openGauss'+item.configGroup]['connection-password']"></el-input>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('openGauss')">提交</el-button>
          </el-row>

        </el-tab-pane>

        <el-tab-pane label="Oracle连接器" name="Oracle">
          <el-tabs v-model="data.Oracle.OracleTabsValue" type="card" editable @edit="handleTabsEdit">
            <el-tab-pane
              :key="item.name"
              v-for="item in data.Oracle.OracleTabs"
              :label="item.title"
              :name="item.name"
            >
              <el-form label-width="200px" class="demo-ruleForm">
                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                    v-model="data.Oracle['Oracle'+item.configGroup]['connector.name']"></el-input>
                </el-form-item>

                <el-form-item label="connection-url:">
                  <el-input class="inputWidth"
                    v-model="data.Oracle['Oracle'+item.configGroup]['connection-url']"></el-input>
                </el-form-item>

                <el-form-item label="connection-user:">
                  <el-input class="inputWidth"
                    v-model="data.Oracle['Oracle'+item.configGroup]['connection-user']"></el-input>
                </el-form-item>

                <el-form-item label="connection-password:">
                  <el-input class="inputWidth"
                    v-model="data.Oracle['Oracle'+item.configGroup]['connection-password']"></el-input>
                </el-form-item>

                <el-form-item label="jdbc.pushdown-enabled:" prop="jdbc.pushdown-enabled">
                  <el-switch v-model="data.Oracle['Oracle'+item.configGroup]['jdbc.pushdown-enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      如果要启用oracle连接器的连接器下推功能，不需要做任何操作，oracle连接器的下推功能默认是打开的。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="jdbc.pushdown-module:">
                  <el-select v-model="data.Oracle['Oracle'+item.configGroup]['jdbc.pushdown-module']" placeholder="请选择">
                    <el-option label="FULL_PUSHDOWN" value='FULL_PUSHDOWN'></el-option>
                    <el-option label="BASE_PUSHDOWN" value="BASE_PUSHDOWN"></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      如果要启用oracle连接器的全部下推功能，不需要做任何操作，oracle连接器的下推模式默认是全部下推的。
                      <br/>#FULL_PUSHDOWN，表示全部下推；BASE_PUSHDOWN，表示部分下推
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="unsupported-type.handling-strategy:">
                  <el-select v-model="data.Oracle['Oracle'+item.configGroup]['unsupported-type.handling-strategy']" placeholder="请选择">
                    <el-option label="FAIL" value='FAIL'></el-option>
                    <el-option label="IGNORE" value="IGNORE "></el-option>
                    <el-option label="CONVERT_TO_VARCHAR" value='CONVERT_TO_VARCHAR'></el-option>
                    <el-option label="VARCHAR" value="VARCHAR "></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      配置如何处理不受支持的列数据类型:
                      <br/>FAIL-直接报错。
                      <br/>IGNORE -无法访问列。
                      <br/>CONVERT_TO_VARCHAR-列转换为无界VARCHAR。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="oracle.number.default-scale:">
                  <el-input class="inputWidth"
                    v-model="data.Oracle['Oracle'+item.configGroup]['oracle.number.default-scale']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Oracle的number数据类型未指定精度和小数位数时，转换为openLooKeng数据类型，会根据该配置进行精度转换。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="oracle.number.rounding-mode:">
                  <el-select v-model="data.Oracle['Oracle'+item.configGroup]['oracle.number.rounding-mode']" placeholder="请选择">
                    <el-option label="UNNECESSARY" value='UNNECESSARY'></el-option>
                    <el-option label="CEILING" value="CEILING"></el-option>
                    <el-option label="FLOOR" value='FLOOR'></el-option>
                    <el-option label="HALF_DOWN " value="HALF_DOWN "></el-option>
                    <el-option label="HALF_EVEN" value='HALF_EVEN'></el-option>
                    <el-option label="HALF_UP" value="HALF_UP"></el-option>
                    <el-option label="UP" value='UP'></el-option>
                    <el-option label="DOWN " value="DOWN "></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      OracleNUMBER数据类型的舍入模式。当OracleNUMBER数据类型指定的规模大于Presto支持的规模时，此功能很有用。可能的值为：
                      <br/>UNNECESSARY -舍入模式，以断言所请求的操作具有精确的结果，因此不需要舍入。
                      <br/>CEILING -向正无穷大舍入。
                      <br/>FLOOR -向负无穷大舍入。
                      <br/>HALF_DOWN -向最近的邻居舍入，若是两个邻居距离相等，则向下舍入模式
                      <br/>HALF_EVEN-向最近的邻居舍入，若是两个邻居距离相等，则向偶数邻居舍入。
                      <br/>HALF_UP-向最近的邻居舍入，若是两个邻居距离相等，则向上舍入。
                      <br/>UP -舍入模式向零舍入。
                      <br/>DOWN -舍入模式向零舍入。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="oracle.synonyms.enabled:" prop="oracle.synonyms.enabled">
                  <el-switch v-model="data.Oracle['Oracle'+item.configGroup]['oracle.synonyms.enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      基于性能的考虑，openLooKeng默认关闭了Oracle 的SYNONYM 功能。可以通过以下配置来开启
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('Oracle')">提交</el-button>
          </el-row>

        </el-tab-pane>

        <el-tab-pane label="PostgreSQL连接器" name="PostgreSQL">
          <el-tabs v-model="data.PostgreSQL.PostgreSQLTabsValue" type="card" editable @edit="handleTabsEdit">
            <el-tab-pane
              :key="item.name"
              v-for="item in data.PostgreSQL.PostgreSQLTabs"
              :label="item.title"
              :name="item.name"
            >
              <el-form label-width="200px" class="demo-ruleForm">
                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.PostgreSQL['PostgreSQL'+item.configGroup]['connector.name']"></el-input>
                </el-form-item>

                <el-form-item label="connection-url:">
                  <el-input class="inputWidth"
                            v-model="data.PostgreSQL['PostgreSQL'+item.configGroup]['connection-url']"></el-input>
                </el-form-item>

                <el-form-item label="connection-user:">
                  <el-input class="inputWidth"
                            v-model="data.PostgreSQL['PostgreSQL'+item.configGroup]['connection-user']"></el-input>
                </el-form-item>

                <el-form-item label="connection-password:">
                  <el-input class="inputWidth"
                            v-model="data.PostgreSQL['PostgreSQL'+item.configGroup]['connection-password']"></el-input>
                </el-form-item>
              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('PostgreSQL')">提交</el-button>
          </el-row>

        </el-tab-pane>

        <el-tab-pane label="SQLServer连接器" name="SQLServer">
          <el-tabs v-model="data.SQLServer.SQLServerTabsValue" type="card" editable @edit="handleTabsEdit">
            <el-tab-pane
              :key="item.name"
              v-for="item in data.SQLServer.SQLServerTabs"
              :label="item.title"
              :name="item.name"
            >
              <el-form label-width="200px" class="demo-ruleForm">
                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.SQLServer['SQLServer'+item.configGroup]['connector.name']"></el-input>
                </el-form-item>

                <el-form-item label="connection-url:">
                  <el-input class="inputWidth"
                            v-model="data.SQLServer['SQLServer'+item.configGroup]['connection-url']"></el-input>
                </el-form-item>

                <el-form-item label="connection-user:">
                  <el-input class="inputWidth"
                            v-model="data.SQLServer['SQLServer'+item.configGroup]['connection-user']"></el-input>
                </el-form-item>

                <el-form-item label="connection-password:">
                  <el-input class="inputWidth"
                            v-model="data.SQLServer['SQLServer'+item.configGroup]['connection-password']"></el-input>
                </el-form-item>
              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('SQLServer')">提交</el-button>
          </el-row>

        </el-tab-pane>

        <el-tab-pane label="Thrift连接器" name="Thrift">
          <el-tabs v-model="data.Thrift.ThriftTabsValue" type="card" editable @edit="handleTabsEdit">
            <el-tab-pane
              :key="item.name"
              v-for="item in data.Thrift.ThriftTabs"
              :label="item.title"
              :name="item.name"
            >
              <el-form label-width="260px" class="demo-ruleForm">
                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.Thrift['Thrift'+item.configGroup]['connector.name']"></el-input>
                </el-form-item>

                <el-form-item label="presto.thrift.client.addresses:">
                  <el-input class="inputWidth"
                            v-model="data.Thrift['Thrift'+item.configGroup]['presto.thrift.client.addresses']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Thrift服务器位置.表示以逗号分隔的Thrift服务器列表，呈host:port形式。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="presto-thrift.max-response-size:">
                  <el-input class="inputWidth"
                            v-model="data.Thrift['Thrift'+item.configGroup]['presto-thrift.max-response-size']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Thrift服务器返回的最大数据量。 连接器接受的数据响应的最大大小。
                      <br/>此值由连接器在请求数据时发送给Thrift服务器，从而允许它适当地调整响应的大小。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="presto-thrift.metadata-refresh-threads:">
                  <el-input class="inputWidth"
                            v-model="data.Thrift['Thrift'+item.configGroup]['presto-thrift.metadata-refresh-threads']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      元数据缓存刷新线程数
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="presto.thrift.client.max-retries:">
                  <el-input class="inputWidth"
                            v-model="data.Thrift['Thrift'+item.configGroup]['presto.thrift.client.max-retries']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Thrift请求失败最大重试次数
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="presto.thrift.client.max-backoff-delay:">
                  <el-input class="inputWidth"
                            v-model="data.Thrift['Thrift'+item.configGroup]['presto.thrift.client.max-backoff-delay']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      最大重试间隔
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="presto.thrift.client.min-backoff-delay:">
                  <el-input class="inputWidth"
                            v-model="data.Thrift['Thrift'+item.configGroup]['presto.thrift.client.min-backoff-delay']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      最小重试间隔
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="presto.thrift.client.max-retry-time:">
                  <el-input class="inputWidth"
                            v-model="data.Thrift['Thrift'+item.configGroup]['presto.thrift.client.max-retry-time']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Thrift请求所有尝试的最大时长
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="presto.thrift.client.backoff-scale-factor:">
                  <el-input class="inputWidth"
                            v-model="data.Thrift['Thrift'+item.configGroup]['presto.thrift.client.backoff-scale-factor']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      指数后退比例系数
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="presto.thrift.client.connect-timeout:">
                  <el-input class="inputWidth"
                            v-model="data.Thrift['Thrift'+item.configGroup]['presto.thrift.client.connect-timeout']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      连接超时
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="presto.thrift.client.request-timeout:">
                  <el-input class="inputWidth"
                            v-model="data.Thrift['Thrift'+item.configGroup]['presto.thrift.client.request-timeout']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      请求超时
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="presto.thrift.client.socks-proxy:">
                  <el-input class="inputWidth"
                            v-model="data.Thrift['Thrift'+item.configGroup]['presto.thrift.client.socks-proxy']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      SOCKS代理地址
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="presto.thrift.client.max-frame-size:">
                  <el-input class="inputWidth"
                            v-model="data.Thrift['Thrift'+item.configGroup]['presto.thrift.client.max-frame-size']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Thrift原始响应最大长度
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="presto.thrift.client.transport:">
                  <el-select v-model="data.Thrift['Thrift'+item.configGroup]['presto.thrift.client.transport']" placeholder="请选择">
                    <el-option label="UNFRAMED" value='UNFRAMED'></el-option>
                    <el-option label="FRAMED" value="FRAMED "></el-option>
                    <el-option label="HEADER" value='HEADER'></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Thrift传输类型（UNFRAMED、FRAMED、HEADER）
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="presto.thrift.client.protocol:">
                  <el-select v-model="data.Thrift['Thrift'+item.configGroup]['presto.thrift.client.protocol']" placeholder="请选择">
                    <el-option label="BINARY" value='BINARY'></el-option>
                    <el-option label="COMPACT" value="COMPACT "></el-option>
                    <el-option label="FB_COMPACT" value='FB_COMPACT'></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Thrift协议类型（BINARY、COMPACT、FB_COMPACT）
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>
              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('Thrift')">提交</el-button>
          </el-row>

        </el-tab-pane>

        <el-tab-pane label="TPCDS连接器" name="TPCDS">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="连接器1" name="1">
              <el-form label-width="270px" class="demo-ruleForm">

                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.TPCDS['TPCDS1']['connector.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>
              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('TPCDS')">提交</el-button>
          </el-row>

        </el-tab-pane>

        <el-tab-pane label="TPCH连接器" name="TPCH">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="连接器1" name="1">
              <el-form label-width="270px" class="demo-ruleForm">

                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.TPCH['TPCH1']['connector.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>
              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('TPCH')">提交</el-button>
          </el-row>

        </el-tab-pane>


        <el-tab-pane label="VDM连接器" name="VDM">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="连接器1" name="1">
              <el-form label-width="270px" class="demo-ruleForm">

                <el-form-item label="hetu.metastore.type:">
                  <el-input class="inputWidth"
                            v-model="data.VDM['VDM1']['hetu.metastore.type']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      the type of metastore storage
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.db.url:">
                  <el-input class="inputWidth"
                            v-model="data.VDM['VDM1']['hetu.metastore.db.url']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      jdbc connection address of database
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.db.user:">
                  <el-input class="inputWidth"
                            v-model="data.VDM['VDM1']['hetu.metastore.db.user']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      the user name of the database
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.db.password:">
                  <el-input class="inputWidth"
                            v-model="data.VDM['VDM1']['hetu.metastore.db.password']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      the password of database
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.db.password:">
                  <el-input class="inputWidth"
                            v-model="data.VDM['VDM1']['hetu.metastore.db.password']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      the password of database
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.hetufilesystem.profile-name:">
                  <el-input class="inputWidth"
                            v-model="data.VDM['VDM1']['hetu.metastore.hetufilesystem.profile-name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      profile name of hetu file system
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.hetufilesystem.path:">
                  <el-input class="inputWidth"
                            v-model="data.VDM['VDM1']['hetu.metastore.hetufilesystem.path']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      the path of metastore storage in the hetu file system
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.VDM['VDM1']['connector.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('VDM')">提交</el-button>
          </el-row>

        </el-tab-pane>

        <el-tab-pane label="Kylin连接器" name="Kylin">
          <el-tabs v-model="data.Kylin.KylinTabsValue" type="card" editable @edit="handleTabsEdit">
            <el-tab-pane
              :key="item.name"
              v-for="item in data.Kylin.KylinTabs"
              :label="item.title"
              :name="item.name"
            >
              <el-form label-width="260px" class="demo-ruleForm">
                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.Kylin['Kylin'+item.configGroup]['connector.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="connection-url:">
                  <el-input class="inputWidth"
                            v-model="data.Kylin['Kylin'+item.configGroup]['connection-url']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="connection-user:">
                  <el-input class="inputWidth"
                            v-model="data.Kylin['Kylin'+item.configGroup]['connection-user']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="connection-password:">
                  <el-input class="inputWidth"
                            v-model="data.Kylin['Kylin'+item.configGroup]['connection-password']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="connector-planoptimizer-rule-blacklist:">
                  <el-input class="inputWidth"
                            v-model="data.Kylin['Kylin'+item.configGroup]['connector-planoptimizer-rule-blacklist']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('Kylin')">提交</el-button>
          </el-row>

        </el-tab-pane>

        <el-tab-pane label="OmniData连接器" name="OmniData">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="连接器1" name="1">
              <el-form label-width="270px" class="demo-ruleForm">

                <el-form-item label="connector.name:">
                  <el-input class="inputWidth"
                            v-model="data.OmniData['OmniData1']['connector.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.metastore.uri:">
                  <el-input class="inputWidth"
                            v-model="data.OmniData['OmniData1']['hive.metastore.uri']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.config.resources:">
                  <el-input class="inputWidth"
                            v-model="data.OmniData['OmniData1']['hive.config.resources']"></el-input>
                  <i class="el-icon-upload"></i>
                  <el-tooltip placement="top">
                    <div slot="content">
                      以逗号分隔的可选HDFS配置文件列表。这些文件必须存在于运行openLooKeng的机器上。
                      <br/>该属性仅在访问HDFS绝对必要的情况下指定。示例：/etc/hdfs-site.xml
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.metastore:">
                  <el-input class="inputWidth"
                            v-model="data.OmniData['OmniData1']['hive.metastore']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Hive元存储类型
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.omnidata-enabled:" prop="hive.omnidata-enabled">
                  <el-switch v-model="data.OmniData['OmniData1']['hive.omnidata-enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      允许下推算子到存储侧执行。如果被禁用，所有算子将不会被下推。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.min-offload-row-number:">
                  <el-input class="inputWidth"
                            v-model="data.OmniData['OmniData1']['hive.min-offload-row-number']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      若数据表的行数小于该阈值，则该数据表的所有算子将不会被下推。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.filter-offload-enabled:" prop="hive.filter-offload-enabled">
                  <el-switch v-model="data.OmniData['OmniData1']['hive.filter-offload-enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      允许下推filter算子到存储侧执行。如果被禁用，filter算子将不会被下推。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.filter-offload-factor:">
                  <el-input class="inputWidth"
                            v-model="data.OmniData['OmniData1']['hive.filter-offload-factor']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      filter算子被下推时的数据选择率阈值。只有当算子的选择率小于该阈值，该算子它才会被下推。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.aggregator-offload-enabled:" prop="hive.aggregator-offload-enabled">
                  <el-switch v-model="data.OmniData['OmniData1']['hive.aggregator-offload-enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      允许下推aggregator算子到存储侧执行。如果被禁用，aggregator算子将不会被下推。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.aggregator-offload-factor:">
                  <el-input class="inputWidth"
                            v-model="data.OmniData['OmniData1']['hive.aggregator-offload-factor']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      aggregator算子被下推时的数据聚合率阈值。只有当算子的聚合率小于该阈值，该算子才会被下推。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('OmniData')">提交</el-button>
          </el-row>

        </el-tab-pane>
      </el-tabs>
    </el-tab-pane>
    <el-tab-pane label="特性配置" name="five">
      <el-tabs :tab-position="tabPosition" style="height: 100%;">
        <el-tab-pane label="资源组">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="资源组" name="1">
              <el-form label-width="350px" class="demo-ruleForm">

                <el-form-item label="resource-groups.configuration-manager:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['resource-groups.configuration-manager']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="resource-groups.config-file:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['resource-groups.config-file']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      将resource-groups.config-file的值修改为指向一个JSON配置文件，可以是绝对路径，也可以是相对于openLooKeng数据目录的路径。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="resource-groups.memory-margin-percent:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['resource-groups.memory-margin-percent']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      这是两个被认为相同的查询之间所允许的内存变化百分比。
                      <br/>在此情况下，查询不会根据内存使用情况进行排序，而是根据查询执行进度进行排序，前提是查询进度差异大于配置差异。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="resource-groups.query-progress-margin-percent:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['resource-groups.query-progress-margin-percent']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      这是两个被认为相同的查询之间所允许的查询执行进度百分比。在此情况下，查询不会根据执行进度进行排序。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="name:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      群组名称。可以是模板
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="maxQueued:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['maxQueued']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      最大排队查询数。一旦达到此限制，新的查询将被拒绝。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hardConcuritiesLimit:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['hardConcuritiesLimit']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      最大运行查询数。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="softMemoryLimit:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['softMemoryLimit']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      新查询进入队列之前，该组可以使用的最大分布式内存量。可指定为集群内存的绝对值（如1GB）或百分比（如10%）。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="softCpuLimit:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['softCpuLimit']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      在对最大运行查询数进行惩罚之前的时间内（参见cpuQuotaPeriod），该组可能使用的最大CPU时间。同时必须指定hardCpuLimit。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hardCpuLimit:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['hardCpuLimit']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      该组在一段时间内可能使用的最大CPU时间。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="schedulingPolicy:">
                  <el-select v-model="data.resourceGroup['resourceGroup1']['schedulingPolicy']" placeholder="请选择">
                    <el-option label="fair" value='fair'></el-option>
                    <el-option label="weighted_fair" value="weighted_fair "></el-option>
                    <el-option label="weighted" value='weighted'></el-option>
                    <el-option label="query_priority" value='query_priority'></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      指定如何选择运行排队的查询，以及子组如何成为符合条件的查询。可以配置为以下三种策略之一。
                      <br/>当集群开启高可用模式（多个coordinator）时，仅支持fair调度策略：
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="schedulingWeight:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['schedulingWeight']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      该子组的权重
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="jmxExport:" prop="jmxExport">
                  <el-switch v-model="data.resourceGroup['resourceGroup1']['jmxExport']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      如果为true，则导出群组统计信息到JMX进行监控。默认为false。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="subGroups:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['subGroups']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      子组列表。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="killPolicy:">
                  <el-select v-model="data.resourceGroup['resourceGroup1']['killPolicy']" placeholder="请选择">
                    <el-option label="no_kill" value='no_kill'></el-option>
                    <el-option label="recent_queries" value="recent_queries "></el-option>
                    <el-option label="oldest_queries" value='oldest_queries'></el-option>
                    <el-option label="high_memory_queries" value='high_memory_queries'></el-option>
                    <el-option label="finish_percentage_queries" value='finish_percentage_queries'></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      当查询提交给worker后，如果总内存使用量超过softMemoryLimit，选择其中一种策略终止正在运行的查询。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="user:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['user']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      用于匹配用户名的正则表达式。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="source:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['user']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      用于匹配源字符串的正则表达式。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="queryType:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['queryType']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      用于匹配提交的查询类型的字符串。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="DATA_DEFINITION:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['DATA_DEFINITION']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      修改/创建/删除模式/表/视图的元数据，以及管理预备语句、权限、会话和事务的查询。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="DELETE:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['DELETE']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      DELETE查询。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="DESCRIBE:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['DESCRIBE']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      DESCRIBE、DESCRIBE INPUT、DESCRIBE OUTPUT以及SHOW查询。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="cpuQuotaPeriod:">
                  <el-input class="inputWidth"
                            v-model="data.resourceGroup['resourceGroup1']['cpuQuotaPeriod']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      CPU配额的执行周期。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('resourceGroup')">提交</el-button>
          </el-row>

        </el-tab-pane>

        <el-tab-pane label="动态过滤">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="动态过滤" name="1">
              <el-form label-width="350px" class="demo-ruleForm">

                <el-form-item label="enable-dynamic-filtering:" prop="enable-dynamic-filtering">
                  <el-switch v-model="data.dynamicFiltering['dynamicFiltering1']['enable-dynamic-filtering']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      是否开启动态过滤特性。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dynamic-filtering-wait-time:">
                  <el-input class="inputWidth"
                            v-model="data.dynamicFiltering['dynamicFiltering1']['dynamic-filtering-wait-time']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      等待动态过滤条件生成的最长等待时间，默认值是1s。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dynamic-filtering-data-type:">
                  <el-select v-model="data.dynamicFiltering['dynamicFiltering1']['dynamic-filtering-data-type']" placeholder="请选择">
                    <el-option label="BLOOM_FILTER" value='BLOOM_FILTER'></el-option>
                    <el-option label="HASHSET" value="HASHSET "></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      设置动态过滤类型，可选包含BLOOM_FILTER以及HASHSET，默认类型为BLOOM_FILTER。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dynamic-filtering-max-size:">
                  <el-input class="inputWidth"
                            v-model="data.dynamicFiltering['dynamicFiltering1']['dynamic-filtering-max-size']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      每个dynamic filter的大小上限，如果预估大小超过设定值，代价优化器不会生成对应的dynamic filter，默认值是1000000。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dynamic-filtering-max-per-driver-size:">
                  <el-input class="inputWidth"
                            v-model="data.dynamicFiltering['dynamicFiltering1']['dynamic-filtering-max-per-driver-size']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      每个driver可以收集的数据大小上限，默认值是1MB。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dynamic-filtering-max-per-driver-row-count:">
                  <el-input class="inputWidth"
                            v-model="data.dynamicFiltering['dynamicFiltering1']['dynamic-filtering-max-per-driver-row-count']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      每个driver可以收集的数据条目上限，默认值是10000。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="dynamic-filtering-bloom-filter-fpp:">
                  <el-input class="inputWidth"
                            v-model="data.dynamicFiltering['dynamicFiltering1']['dynamic-filtering-bloom-filter-fpp']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      动态过滤使用的bloomfilter的FPP值，默认是0.1。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.dynamic-filter-partition-filtering:" prop="hive.dynamic-filter-partition-filtering">
                  <el-switch v-model="data.dynamicFiltering['dynamicFiltering1']['hive.dynamic-filter-partition-filtering']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      使用动态过滤条件根据分区值进行预先过滤，默认值是false。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hive.dynamic-filtering-row-filtering-threshold:">
                  <el-input class="inputWidth"
                            v-model="data.dynamicFiltering['dynamicFiltering1']['hive.dynamic-filtering-row-filtering-threshold']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      如果动态过滤条件大小低于阈值，则应用行过滤。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('dynamicFiltering')">提交</el-button>
          </el-row>

        </el-tab-pane>

        <el-tab-pane label="状态存储">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="状态存储" name="1">
              <el-form label-width="350px" class="demo-ruleForm">

                <el-form-item label="hetu.embedded-state-store.enabled:" prop="hetu.embedded-state-store.enabled">
                  <el-switch v-model="data.stateStorage['stateStorage1']['hetu.embedded-state-store.enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      配置状态存储成员
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="state-store.type:">
                  <el-input class="inputWidth"
                            v-model="data.stateStorage['stateStorage1']['state-store.type']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      状态存储的类型。目前仅支持Hazelcast。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="state-store.name:">
                  <el-input class="inputWidth"
                            v-model="data.stateStorage['stateStorage1']['state-store.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      用户定义的状态存储名称。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="state-store.cluster:">
                  <el-input class="inputWidth"
                            v-model="data.stateStorage['stateStorage1']['state-store.cluster']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      用户定义的状态存储集群名称。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hazelcast.discovery.mode:">
                  <el-select v-model="data.stateStorage['stateStorage1']['hazelcast.discovery.mode']" placeholder="请选择">
                    <el-option label="tcp-ip" value='tcp-ip'></el-option>
                    <el-option label="multicast" value="multicast "></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      Hazelcast状态存储发现模式, 目前支持tcp-ip和multicast（默认）。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hazelcast.discovery.port:">
                  <el-input class="inputWidth"
                            v-model="data.stateStorage['stateStorage1']['hazelcast.discovery.port']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      用户定义hazelcast启动端口。该属性可选，默认端口为5701。只需状态存储成员配置该项。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hazelcast.discovery.tcp-ip.seeds:">
                  <el-input class="inputWidth"
                            v-model="data.stateStorage['stateStorage1']['hazelcast.discovery.tcp-ip.seeds']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      状态存储成员种子列表用来启动状态存储集群。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hazelcast.discovery.tcp-ip.profile:">
                  <el-input class="inputWidth"
                            v-model="data.stateStorage['stateStorage1']['hazelcast.discovery.tcp-ip.profile']"></el-input>
                  <i class="el-icon-upload"></i>
                  <el-tooltip placement="top">
                    <div slot="content">
                      状态存储成员种子列表用来启动状态存储集群。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="fs.client.type:">
                  <el-input class="inputWidth"
                            v-model="data.stateStorage['stateStorage1']['fs.client.type']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hdfs.config.resources:">
                  <el-input class="inputWidth"
                            v-model="data.stateStorage['stateStorage1']['hdfs.config.resources']"></el-input>
                  <i class="el-icon-upload"></i>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hdfs.authentication.type:">
                  <el-select v-model="data.stateStorage['stateStorage1']['hdfs.authentication.type']" placeholder="请选择">
                    <el-option label="KERBEROS" value='KERBEROS'></el-option>
                    <el-option label="NONE" value="NONE"></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      # hdfs authentication, accepted values: KERBEROS/NONE
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="fs.hdfs.impl.disable.cache:" prop="fs.hdfs.impl.disable.cache">
                  <el-switch v-model="data.stateStorage['stateStorage1']['fs.hdfs.impl.disable.cache']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('stateStorage')">提交</el-button>
          </el-row>

        </el-tab-pane>

        <el-tab-pane label="元数据存储">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="状态存储" name="1">
              <el-form label-width="350px" class="demo-ruleForm">

                <el-form-item label="hetu.metastore.type:">
                  <el-input class="inputWidth"
                            v-model="data.metadataStore['metadataStore1']['hetu.metastore.type']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      元数据存储类型，使用RDBMS存储时配置为jdbc。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.db.url:">
                  <el-input class="inputWidth"
                            v-model="data.metadataStore['metadataStore1']['hetu.metastore.db.url']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      连接RDBMS的URL。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.db.user:">
                  <el-input class="inputWidth"
                            v-model="data.metadataStore['metadataStore1']['hetu.metastore.db.user']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      连接RDBMS的用户名。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.db.password:">
                  <el-input class="inputWidth"
                            v-model="data.metadataStore['metadataStore1']['hetu.metastore.db.password']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      连接RDBMS的密码。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.cache.type:">
                  <el-select v-model="data.metadataStore['metadataStore1']['hetu.metastore.cache.type']" placeholder="请选择">
                    <el-option label="global" value='global'></el-option>
                    <el-option label="local" value="local"></el-option>
                  </el-select>
                  <el-tooltip placement="top">
                    <div slot="content">
                      选择缓存模型,其中local为本地缓存,global为分布式缓存。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.hetufilesystem.profile-name:">
                  <el-input class="inputWidth"
                            v-model="data.metadataStore['metadataStore1']['hetu.metastore.hetufilesystem.profile-name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      使用HDFS存储配置文件的名称。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.hetufilesystem.path:">
                  <el-input class="inputWidth"
                            v-model="data.metadataStore['metadataStore1']['hetu.metastore.hetufilesystem.path']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      配置文件的路径。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.cache.size:">
                  <el-input class="inputWidth"
                            v-model="data.metadataStore['metadataStore1']['hetu.metastore.cache.size']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      元数据缓存大小，默认10000。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.metastore.cache.ttl:">
                  <el-input class="inputWidth"
                            v-model="data.metadataStore['metadataStore1']['hetu.metastore.cache.ttl']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      缓存元数据的过期时间，默认值0 (元数据缓存关闭)。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('metadataStore')">提交</el-button>
          </el-row>

        </el-tab-pane>

        <el-tab-pane label="审计日志">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="审计日志" name="1">
              <el-form label-width="350px" class="demo-ruleForm">

                <el-form-item label="event-listener.name:">
                  <el-input class="inputWidth"
                            v-model="data.auditLog['auditLog1']['event-listener.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.event.listener.type:">
                  <el-input class="inputWidth"
                            v-model="data.auditLog['auditLog1']['hetu.event.listener.type']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.event.listener.listen.query.creation:" prop="hetu.event.listener.listen.query.creation">
                  <el-switch v-model="data.auditLog['auditLog1']['hetu.event.listener.listen.query.creation']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.event.listener.listen.query.completion:" prop="hetu.event.listener.listen.query.completion">
                  <el-switch v-model="data.auditLog['auditLog1']['hetu.event.listener.listen.query.completion']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">

                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.event.listener.audit.file:">
                  <el-input class="inputWidth"
                            v-model="data.auditLog['auditLog1']['hetu.event.listener.audit.file']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      可选属性，用于定义审计文件的绝对文件路径。确保运行openLooKeng服务器的进程对该目录有写权限。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.event.listener.audit.filecount:">
                  <el-input class="inputWidth"
                            v-model="data.auditLog['auditLog1']['hetu.event.listener.audit.filecount']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      可选属性，用于定义要使用的文件数。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="hetu.event.listener.audit.limit:">
                  <el-input class="inputWidth"
                            v-model="data.auditLog['auditLog1']['hetu.event.listener.audit.limit']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      可选属性，用于定义写入任一文件的最大字节数。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('auditLog')">提交</el-button>
          </el-row>

        </el-tab-pane>
      </el-tabs>

    </el-tab-pane>
    <el-tab-pane label="安全配置" name="six">

      <el-tabs :tab-position="tabPosition" style="height: 100%;">
        <el-tab-pane label="LDAP认证">
          <el-tabs v-model="defaultActivityName" type="card" @tab-click="handleClick">
            <el-tab-pane label="LDAP认证" name="1">
              <el-form label-width="350px" class="demo-ruleForm">

                <el-form-item label="http-server.authentication.type:">
                  <el-input class="inputWidth"
                            v-model="data.LDAP['LDAP1']['http-server.authentication.type']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      对openLooKeng协调节点开启密码认证功能。必须设置为PASSWORD。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="http-server.https.enabled:" prop="http-server.https.enabled">
                  <el-switch v-model="data.LDAP['LDAP1']['http-server.https.enabled']"></el-switch>
                  <el-tooltip placement="top">
                    <div slot="content">
                      对openLooKeng协调节点开启HTTPS访问功能。取值设置为true。默认值为false。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="http-server.https.port:">
                  <el-input class="inputWidth"
                            v-model="data.LDAP['LDAP1']['http-server.https.port']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      HTTPS服务器的端口号。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="http-server.https.keystore.path:">
                  <el-input class="inputWidth"
                            v-model="data.LDAP['LDAP1']['http-server.https.keystore.path']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      用于保证TLS安全连接的Java密钥库文件的位置。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="http-server.https.keystore.key:">
                  <el-input class="inputWidth"
                            v-model="data.LDAP['LDAP1']['http-server.https.keystore.key']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      密钥库的密码。必须与创建密钥库时设置的密码一致。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="http-server.authentication.password.user-mapping.pattern:">
                  <el-input class="inputWidth"
                            v-model="data.LDAP['LDAP1']['http-server.authentication.password.user-mapping.pattern']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      用于认证用户匹配的正则表达式。如果匹配，认证用户映射到正则表达式中的第一个匹配组；如果不匹配，则拒绝认证。默认值是(.*)。
                      <br/>注意:http-server.authentication.password.user-mapping.pattern和http-server.authentication.password.user-mapping.file不能同时设置。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="http-server.authentication.password.user-mapping.file:">
                  <el-input class="inputWidth"
                            v-model="data.LDAP['LDAP1']['http-server.authentication.password.user-mapping.file']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      包含用户映射规则的JSON文件。详见 认证用户映射。
                      <br/>注意:http-server.authentication.password.user-mapping.pattern和http-server.authentication.password.user-mapping.file不能同时设置。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="password-authenticator.name:">
                  <el-input class="inputWidth"
                            v-model="data.LDAP['LDAP1']['password-authenticator.name']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      password-authenticator.name
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="ldap.url:">
                  <el-input class="inputWidth"
                            v-model="data.LDAP['LDAP1']['ldap.url']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      指向LDAP服务器的URL。由于openLooKeng只允许使用安全的LDAP，所以url模式必须是ldaps://。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="ldap.user-bind-pattern:">
                  <el-input class="inputWidth"
                            v-model="data.LDAP['LDAP1']['ldap.user-bind-pattern']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      该属性可用于为密码验证指定LDAP用户绑定字符串。该属性必须包含${USER}，在密码验证期间，该字段将被实际的用户名替换。
                      <br/>例如: ${USER}@corp.example.com.
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="ldap.user-base-dn:">
                  <el-input class="inputWidth"
                            v-model="data.LDAP['LDAP1']['ldap.user-base-dn']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      尝试连接到服务器的用户的LDAP基本标识名。例如: OU=America,DC=corp,DC=example,DC=com
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

                <el-form-item label="ldap.group-auth-pattern:">
                  <el-input class="inputWidth"
                            v-model="data.LDAP['LDAP1']['ldap.group-auth-pattern']"></el-input>
                  <el-tooltip placement="top">
                    <div slot="content">
                      该属性用于指定LDAP群组成员授权的LDAP查询。该查询将针对LDAP服务器执行，如果成功，用户将获得授权。
                      <br/>此属性必须包含一个${USER}，它将在群组授权搜索查询中被替换为实际的用户名。见以下示例。
                    </div>
                    <i class="el-icon-question"></i>
                  </el-tooltip>
                </el-form-item>

              </el-form>
            </el-tab-pane>
          </el-tabs>

          <el-row>
            <el-button>取消</el-button>
            <el-button type="primary" @click="saveConfig('LDAP')">提交</el-button>
          </el-row>

        </el-tab-pane>

      </el-tabs>

    </el-tab-pane>
  </el-tabs>
</template>
<script>

  import {doGet, doPost} from '@/api/index.js'
  import nodelist from '@/view/node/list'

  export default {
    props: {},
    name: 'cluster-detail',
    mounted () {
      this.getClusterConfig()
    },
    created(){
      this.clusterCode=this.$route.query.clusterCode
    },
    components: {
      'nodelist': nodelist
    },
    data () {
      return {
        clusterCode: '',
        defaultActivityName: '1',
        firstZL:'firstZL',
        CarbonDataName: 'CarbonData',
        currentConfigType: 'ClickHouse',
        activeName: 'second',
        tabPosition: 'left',
        data: {

          'common': {
            'common1': {
              'join-distribution-type': 'AUTOMATIC',
              'redistribute-writes': true,
              'stack-trace-visible': false,
              'openlookeng.admins': '',

              'http-header.content-security-policy': 'object-src \'none\'',
              'http-header.referrer-policy': 'strict-origin-when-cross-origin',
              'http-header.x-content-type-options': 'nosniff',
              'http-header.x-frame-options': 'deny',
              'http-header.x-permitted-cross-domain-policies': 'master-only',
              'http-header.x-xss-protection': '1; mode=block',

              'query.max-memory-per-node': 'JVM max memory * 0.1',
              'query.max-total-memory-per-node': 'JVM max memory * 0.3',
              'query.max-memory': '20GB',
              'query.max-total-memory': 'query.max-memory * 2',
              'memory.heap-headroom-per-node': 'JVM max memory * 0.3',

              'experimental.spill-enabled': false,
              'experimental.spill-order-by': true,
              'experimental.spill-window-operator': true,
              'experimental.spill-reuse-tablescan': false,
              'experimental.spiller-spill-path`': '',

              'exchange.client-threads': 25,
              'exchange.concurrent-request-multiplier': 3,
              'exchange.max-buffer-size': '32MB',
              'exchange.max-response-size': '16MB',
              'exchange.max-error-duration': '7m',
              'sink.max-buffer-size': '32MB',

              'task.concurrency': 16,
              'task.http-response-threads': 100,
              'task.http-timeout-threads': 3,
              'task.info-update-interval': '3s',
              'task.max-partial-aggregation-memory': '16MB',
              'task.max-worker-threads': 'Node CPUs * 2',
              'task.min-drivers': 'task.max-worker-threads * 2',
              'task.writer-count': 1,

              'node-scheduler.max-splits-per-node': 100,
              'node-scheduler.max-pending-splits-per-task': 10,
              'node-scheduler.min-candidates': 10,
              'node-scheduler.network-topology': 'legacy',

              'optimizer.dictionary-aggregation': false,
              'optimizer.optimize-hash-generation': true,
              'optimizer.optimize-metadata-queries': false,
              'optimizer.push-aggregation-through-join': true,
              'optimizer.push-table-write-through-union': true,

              'optimizer.join-reordering-strategy': 'AUTOMATIC',
              'optimizer.max-reordered-joins': 9,
              'hetu.query-pushdown': true,
              'optimizer.reuse-table-scan': false,
              'optimizer.cte-reuse-enabled': false,
              'optimizer.sort-based-aggregation-enabled': false,

              'hetu.heuristicindex.filter.enabled': false,
              'hetu.heuristicindex.filter.cache.max-memory': '10GB',
              'hetu.heuristicindex.filter.cache.soft-reference': true,
              'hetu.heuristicindex.filter.cache.ttl': '24h',
              'hetu.heuristicindex.filter.cache.loading-threads': 10,
              'hetu.heuristicindex.filter.cache.loading-delay': '10s',
              'hetu.heuristicindex.filter.cache.preload-indices': '',
              'hetu.heuristicindex.indexstore.uri': '/opt/hetu/indices/',
              'hetu.heuristicindex.indexstore.filesystem.profile': '',

              'hetu.executionplan.cache.enabled': false,
              'hetu.executionplan.cache.limit': 1000,
              'hetu.executionplan.cache.timeout': '86400000 ms',

              'hetu.split-cache-map.enabled': false,
              'hetu.split-cache-map.state-update-interval': '2 seconds',

              'auto-vacuum.enabled:': false,
              'auto-vacuum.scan.interval': '10m',
              'auto-vacuum.scan.threads': 3,

              'cte.cte-max-queue-size': 1024,
              'cte.cte-max-prefetch-queue-size': 512,

              'sort.prcnt-drivers-for-partial-aggr': 5,

              'query.remote-task.max-error-duration': '5m',

              'snapshot_enabled': false,
              'hetu.experimental.snapshot.profile': '',
              'hetu.snapshot.maxRetries': 10,
              'hetu.snapshot.retryTimeout': '10m',

            }
          },
          'jvm': {
            'jvm1': {
              'jvm': ''
            }
          },
          'CarbonData': {
            'CarbonData1': {
              'connector.name': 'carbondata',
              'hive.metastore.uri': 'thrift://example.net:9083',
              '-DHADOOP_USER_NAME': 'hdfs_user',
              'carbondata.store-location': '${hive.metastore.warehouse.dir} /carbon.store',
              'carbondata.minor-vacuum-seg-count': 'NONE',
              'carbondata.major-vacuum-seg-size': '1GB',
              'hive.metastore': 'thrift',
              'hive.config.resources': '/etc/hadoop/conf/core-site.xml,/etc/hadoop/conf/hdfs-site.xml,/etc/hadoop/conf/yarn-site.xml,/etc/hadoop/conf/mapred-site.xml',
              'hive.hdfs.authentication.type': 'NONE',
              'hive.hdfs.impersonation.enabled': false,
              'hive.hdfs.presto.principal': '',
              'hive.hdfs.presto.keytab': '',
              'hive.collect-column-statistics-on-write': true,
              'carbondata.vacuum-service-threads': 2,
              'carbondata.auto-vacuum-enabled': false,
              'hive.metastore.username': '',
              'hive.metastore.authentication.type': 'NONE',
              'hive.metastore.service.principal': '',
              'hive.metastore.client.principal': '',
              'hive.metastore.client.keytab': ''
            }

          },
          'ClickHouse': {
            ClickHouseTabsValue: '1',
            ClickHouseTabIndex: 1,
            ClickHouseTabs: [
              {
                title: '连接器1',
                name: '1',
                configGroup: '1',
              }
            ],
            'ClickHouse1': {
              'connector.name': 'clickhouse',
              'connection-url': 'jdbc:clickhouse0://example.net:8123',
              'connection-user': 'username',
              'connection-password': 'yourpassword',
              'allow-drop-table': true,
              'clickhouse.query.pushdown.enabled': true,
              'case-insensitive-name-matching': true
            },
          },
          //data center
          'dataCenter': {
            dataCenterTabsValue: '1',
            dataCenterTabIndex: 1,
            dataCenterTabs: [
              {
                title: '连接器1',
                name: '1',
                configGroup: '1',
              }
            ],
            'dataCenter1': {
              'connector.name': 'dc',
              'connection-url': 'http://example.net:8080',
              'connection-user': '<远端openLooKeng用户名>',
              'connection-password': '<远端openLooKeng密码>',
              'dc.kerberos.config.path': '',
              'dc.kerberos.credential.cachepath': '',
              'dc.kerberos.keytab.path': '',
              'dc.kerberos.principal': '',
              'dc.kerberos.remote.service.name': '',
              'dc.kerberos.service.principal.pattern': '${SERVICE}@${HOST}',
              'dc.kerberos.use.canonical.hostname': false,
              'dc.accesstoken': '',
              'dc.extra.credentials': '',
              'dc.ssl': false,
              'dc.ssl.keystore.password': '',
              'dc.ssl.keystore.path': '',
              'dc.ssl.truststore.password': '',
              'dc.ssl.truststore.path': '',
              'dc.socksproxy': '',
              'dc.httpproxy': '',
              'dc.metadata.cache.enabled': true,
              'dc.metadata.cache.maximum.size': 10000,
              'dc.metadata.cache.ttl': '1.00s',
              'dc.query.pushdown.enabled': true,
              'dc.query.pushdown.modul': 'FULL_PUSHDOWN',
              'dc.http-compression': false,
              'dc.http-request-connectTimeout': '30.00s',
              'dc.http-request-readTimeout': '30.00s',
              'dc.httpclient.maximum.idle.connections': 20,
              'dc.http-client-timeout': '10.00m',
              'dc.max.anticipated.delay': '10.00m',
              'dc.application.name.prefix': 'hetu-dc',
              'dc.remote-http-server.max-request-header-size': '',
              'dc.remote.cluster.id': '',
              'hetu.data.center.split.count': 5,
              'hetu.data.center.consumer.timeout': '10min',
              'enable-dynamic-filtering': false,
              'dynamic-filtering-max-per-driver-row-count': 100,
              'dynamic-filtering-max-per-driver-size': '10KB'
            }

          },
          'Elasticsearch': {
            'Elasticsearch1': {
              'connector.name': 'elasticsearch',
              'elasticsearch.host': 'localhost',
              'elasticsearch.port': '9200',
              'elasticsearch.default-schema-name': 'default',
              'elasticsearch.scroll-size': 1000,
              'elasticsearch.scroll-timeout': '1m',
              'elasticsearch.request-timeout': '10s',
              'elasticsearch.connect-timeout': '1s',
              'elasticsearch.max-retry-time': '20s',
              'elasticsearch.node-refresh-interval': '1m',
              'elasticsearch.security': 'PASSWORD',
              'elasticsearch.auth.user': '',
              'elasticsearch.auth.password': '',
              'elasticsearch.tls.keystore-path': '',
              'elasticsearch.tls.truststore-path': '',
              'elasticsearch.tls.keystore-password': '',
              'elasticsearch.tls.truststore-password': ''
            }
          },
          'Greenplum': {
            'Greenplum1': {
              'connector.name': 'greenplum',
              'connection-url': 'jdbc:postgresql',
              'connection-user': 'root',
              'connection-password': 'secret',
              'greenplum.allow-modify-table': true,
              'jdbc.pushdown-enabled': false,
              'jdbc.pushdown-module': 'BASE_PUSHDOWN'
            }
          },
          'Hana': {
            HanaTabsValue: '1',
            HanaTabIndex: 1,
            HanaTabs: [
              {
                title: '连接器1',
                name: '1',
                configGroup: '1',
              }
            ],
            'Hana1': {
              'connector.name': 'hana',
              'connection-url': 'jdbc:sap://主机:端口',
              'connection-use': '用户名',
              'connection-password': '密码',
              'allow-drop-table': true,
              'jdbc.pushdown-enabled': true,
              'jdbc.pushdown-module': 'FULL_PUSHDOWN'
            }
          },
          'HBase':{
            'HBase1':{
              'connector.name':'hbase-connector',
              'hbase.zookeeper.quorum':'xxx.xxx.xxx.xxx,xxx.xxx.xxx.xxx',
              'hbase.zookeeper.property.clientPort':'xxxx',
              'hbase.zookeeper.znode.parent':'\t/hbase',
              'hbase.client.retries.number':3,
              'hbase.client.pause.time':100,
              'hbase.rpc.protection.enable':false,
              'hbase.default.value':'NULL',
              'hbase.metastore.type':'\thetuMetastore\t',
              'hbase.authentication.type':'（无）',
              'hbase.kerberos.principal':'（无）',
              'hbase.kerberos.keytab':'（无）',
              'hbase.client.side.enable':false,
              'hbase.hbase.site.path':'（无）',
              'hbase.client.side.snapshot.retry':100,
              'hbase.hdfs.site.path':'（无）',
              'hbase.core.site.path':'（无）',
              'hbase.jaas.conf.path':'（无）',
              'hbase.krb5.conf.path':'（无）'
            }
          },
          'Hive':{
            'Hive1':{
              'connector.name':'hive-hadoop2',
              'hive.metastore.uri':'thrift://example.net:9083',
              'hive.config.resources':'',
              '-DHADOOP_USER_NAME':'hdfs_user',
              'hive.metastore':'thrift',
              'hive.config.resources':'',
              'hive.recursive-directories':'',
              'hive.storage-format':'ORC',
              'hive.compression-codec':'GZIP',
              'hive.force-local-scheduling':false,
              'hive.respect-table-format':true,
              'hive.immutable-partitions':false,
              'hive.create-empty-bucket-files':false,
              'hive.max-partitions-per-writers':100,
              'hive.max-partitions-per-scan':100000,
              'hive.hdfs.authentication.type':'NONE',
              'hive.hdfs.impersonation.enabled':false,
              'hive.hdfs.presto.principal':'',
              'hive.hdfs.presto.keytab':'',
              'hive.security':'',
              'security.config-file':'',
              'hive.non-managed-table-writes-enabled':false,
              'hive.non-managed-table-creates-enabled':true,
              'hive.collect-column-statistics-on-write':true,
              'hive.s3select-pushdown.enabled':false,
              'hive.s3select-pushdown.max-connections':500,
              'hive.orc.use-column-names':false,
              'hive.orc-predicate-pushdown-enabled':false,
              'hive.orc.time-zone':'JVM默认值',
              'hive.parquet.time-zone':'JVM默认值',
              'hive.rcfile.time-zone':'JVM默认值',
              'hive.vacuum-service-threads':2,
              'hive.auto-vacuum-enabled':false,
              'hive.vacuum-delta-num-threshold':10,
              'hive.vacuum-delta-percent-threshold':0.1,
              'hive.vacuum-cleanup-recheck-interval':'5 Minutes',
              'hive.vacuum-collector-interval':'5 Minutes',
              'hive.max-splits-to-group':1,
              'hive.metastore-client-service-threads':4,
              'hive.worker-metastore-cache-enabled':false,
              'hive.metastore-write-batch-size':8,
              'hive.metastore-cache-ttl':'0s',
              'hive.metastore-refresh-interval':'1s',
              'hive.metastore-db-cache-ttl':'0s',
              'hive.metastore-db-refresh-interval':'1s'
            }
          },
          'Hudi':{
            'Hudi1':{
              'connector.name':'hive-hadoop2',
              'hive.metastore.uri':'thrift://example.net:9083'
            }
          },
          'JMX':{
            'JMX1':{
              'connector.name':'jmx',
              'jmx.dump-period':'10s',
              'jmx.max-entries':86400,
              'jmx.dump-tables':'presto.memory:type=memorypool\\\\,name=general,\\\n' +
                '   presto.memory:type=memorypool\\\\,name=system,\\\n' +
                '   presto.memory:type=memorypool\\\\,name=reserved'
            }
          },
          'Kafka':{
            KafkaTabsValue: '1',
            KafkaTabIndex: 1,
            KafkaTabs: [
              {
                title: '连接器1',
                name: '1',
                configGroup: '1',
              }
            ],
            'Kafka1':{
              'connector.name':'kafka',
              'kafka.nodes':'host1:port,host2:port',
              'kafka.table-names':'table1,table2',
              'kafka.default-schema':'default',
              'kafka.nodes':'',
              'kafka.connect-timeout':'10s',
              'kafka.buffer-size':'64kb',
              'kafka.table-description-dir':'etc/kafka',
              'kafka.hide-internal-columns':true
            }
          },
          //local file connecter
          'localFile':{
            'localFile1':{
              'connector.name':'localfile',
              'presto-logs.http-request-log.location':'',
              'presto-logs.http-request-log.pattern':''
            }
          },
          'memory':{
            'memory1':{
              'connector.name':'memory',
              'memory.max-data-per-node':'200GB',
              'memory.spill-path':'/opt/hetu/data/spill',
              'hetu.metastore.type':'hetufilesystem',
              'hetu.metastore.hetufilesystem.profile-name':'default',
              'hetu.metastore.hetufilesystem.path':'/tmp/hetu/metastore',
              'hetu.metastore.cache.type':'local',
              'memory.spill-path':'None',
              'memory.max-logical-part-size':'256MB',
              'memory.max-page-size':'1MB',
              'memory.logical-part-processing-delay':'5s',
              'memory.thread-pool-size':'Half of threads available to the JVM',
              'hetu.embedded-state-store.enabled':true,
              'state-store.type':'hazelcast',
              'state-store.name':'test',
              'state-store.cluster':'test-cluster',
              'hazelcast.discovery.mode':'tcp-ip',
              'hazelcast.discovery.port':7980,
              'hazelcast.discovery.tcp-ip.seeds':'host1:7980, host2:7980',
              'hetu.metastore.type':'hetufilesystem',
              'hetu.metastore.hetufilesystem.profile-name':'hdfs',
              'hetu.metastore.hetufilesystem.path':'/tmp/hetu/metastore',
              'hetu.metastore.cache.type':'global',
              'fs.client.type':'hdfs',
              'hdfs.config.resources':'',
              'hdfs.authentication.type':'NONE'
            }
          },
          'MongoDB':{
            MongoDBTabsValue: '1',
            MongoDBTabIndex: 1,
            MongoDBTabs: [
              {
                title: '连接器1',
                name: '1',
                configGroup: '1'
              }
            ],
            'MongoDB1':{
              'connector.name':'mongodb',
              'mongodb.seeds':'host1,host:port',
              'mongodb.schema-collection':'_schema',
              'mongodb.case-insensitive-name-matching':false,
              'mongodb.credentials':'',
              'mongodb.min-connectenions-per-host':0,
              'mongodb.connections-per-host':100,
              'mongodb.max-wait-time':120000,
              'mongodb.max-connection-idle-time':'',
              'mongodb.connections-timeout':10000,
              'mongodb.socket-timeout':0,
              'mongodb.socket-keep-alive':false,
              'mongodb.ssl.enabled':false,
              'mongodb.read-preference':'PRIMARY',
              'mongodb.write-concern':'ACKNOWLEDGED',
              'mongodb.required-replica-set':'',
              'mongodb.cursor-batch-size':0
            }
          },
          'MySQL': {
            MySQLTabsValue: '1',
            MySQLTabIndex: 1,
            MySQLTabs: [
              {
                title: '连接器1',
                name: '1',
                configGroup: '1'
              }
            ],
            'MySQL1': {
              'connector.name':'mysql',
              'connection-url':'jdbc:mysql://example.net:3306',
              'connection-user':'root',
              'connection-password':'secret',
              'jdbc.pushdown-enabled':true,
              'jdbc.pushdown-module':'FULL_PUSHDOWN',
              'jdbc.pushdown.remotenamespace':'mysqlfun.default',
            }
          },
          'openGauss': {
            openGaussTabsValue: '1',
            openGaussTabIndex: 1,
            openGaussTabs: [
              {
                title: '连接器1',
                name: '1',
                configGroup: '1'
              }
            ],
            'openGauss1': {
              'connector.name':'opengauss',
              'connection-url':'jdbc:postgresql://example.net:15400/database',
              'connection-user':'root',
              'connection-password':'secret'
            }
          },
          'Oracle': {
            OracleTabsValue: '1',
            OracleTabIndex: 1,
            OracleTabs: [
              {
                title: '连接器1',
                name: '1',
                configGroup: '1'
              }
            ],
            'Oracle1': {
              'connector.name':'oracle',
              'connection-url':'jdbc:oracle:thin:@主机:端口/ORCLCDB',
              'connection-user':'用户名',
              'connection-password':'密码',
              'jdbc.pushdown-enabled':true,
              'jdbc.pushdown-module':'FULL_PUSHDOWN',
              'unsupported-type.handling-strategy':'FAIL',
              'oracle.number.default-scale':0,
              'oracle.number.rounding-mode':'UNNECESSARY',
              'oracle.synonyms.enabled':true
            }
          },
          'PostgreSQL': {
            PostgreSQLTabsValue: '1',
            PostgreSQLTabIndex: 1,
            PostgreSQLTabs: [
              {
                title: '连接器1',
                name: '1',
                configGroup: '1'
              }
            ],
            'PostgreSQL1': {
              'connector.name':'postgresql',
              'connection-url':'jdbc:postgresql://example.net:5432/database',
              'connection-user':'root',
              'connection-password':'secret'
            }
          },
          'SQLServer': {
            SQLServerTabsValue: '1',
            SQLServerTabIndex: 1,
            SQLServerTabs: [
              {
                title: '连接器1',
                name: '1',
                configGroup: '1'
              }
            ],
            'SQLServer1': {
              'connector.name':'sqlserver',
              'connection-url':'jdbc:sqlserver://[serverName[\\instanceName][:portNumber]]',
              'connection-user':'root',
              'connection-password':'secret'
            }
          },
          'Thrift': {
            ThriftTabsValue: '1',
            ThriftTabIndex: 1,
            ThriftTabs: [
              {
                title: '连接器1',
                name: '1',
                configGroup: '1'
              }
            ],
            'Thrift1': {
              'connector.name':'presto-thrift',
              'presto.thrift.client.addresses':'host:port,host:port',
              'presto-thrift.max-response-size':'16MB',
              'presto-thrift.metadata-refresh-threads':1,
              'presto.thrift.client.max-retries':'',
              'presto.thrift.client.max-backoff-delay':'',
              'presto.thrift.client.min-backoff-delay':'',
              'presto.thrift.client.max-retry-time':'',
              'presto.thrift.client.backoff-scale-factor':'',
              'presto.thrift.client.connect-timeout':'',
              'presto.thrift.client.request-timeout':'',
              'presto.thrift.client.socks-proxy':'',
              'presto.thrift.client.max-frame-size':'',
              'presto.thrift.client.transport':'',
              'presto.thrift.client.protocol':''
            }
          },
          'TPCDS':{
            'TPCDS1':{
              'connector.name':'tpcds'
            }
          },
          'TPCH':{
            'TPCH1':{
              'connector.name':'tpch'
            }
          },
          'VDM':{
            'VDM1':{
              'hetu.metastore.type':'jdbc',
              'hetu.metastore.db.url':'jdbc:mysql://....',
              'hetu.metastore.db.user':'root',
              'hetu.metastore.db.password':123456,
              'hetu.metastore.hetufilesystem.profile-name':'hdfs-config-metastore',
              'hetu.metastore.hetufilesystem.path':'/etc/openlookeng/metastore',
              'connector.name':'vdm'
            }
          },
          'Kylin': {
            KylinTabsValue: '1',
            KylinTabIndex: 1,
            KylinTabs: [
              {
                title: '连接器1',
                name: '1',
                configGroup: '1'
              }
            ],
            'Kylin1': {
              'connector.name':'kylin',
              'connection-url':'jdbc:kylin://example.net/project',
              'connection-user':'root',
              'connection-password':'secret',
              'connector-planoptimizer-rule-blacklist':'io.prestosql.sql.planner.iterative.rule.SingleDistinctAggregationToGroupBy',
            }
          },
          'OmniData':{
            'OmniData1':{
              'connector.name':'omnidata-openlookeng',
              'hive.metastore.uri':'thrift://example.net:9083',
              'hive.config.resources':'root',
              'hive.metastore':'thrift',
              'hive.omnidata-enabled':true,
              'hive.min-offload-row-number':500,
              'hive.filter-offload-enabled':true,
              'hive.filter-offload-factor':0.25,
              'hive.aggregator-offload-enabled':true,
              'hive.aggregator-offload-factor':0.25
            }
          },
          //resource group
          'resourceGroup':{
            'resourceGroup1':{
              'resource-groups.configuration-manager':'file',
              'resource-groups.config-file':'etc/resource-groups.json',
              'resource-groups.memory-margin-percent':'10%',
              'resource-groups.query-progress-margin-percent':'5%',
              'name':'',
              'maxQueued':'',
              'hardConcuritiesLimit':'',
              'softMemoryLimit':'',
              'softCpuLimit':'',
              'hardCpuLimit':'',
              'schedulingPolicy':'fair',
              'schedulingWeight':1,
              'jmxExport':false,
              'subGroups':'',
              'killPolicy':'no_kill',
              'user':'',
              'source':'',
              'queryType':'',
              'DATA_DEFINITION':'',
              'DELETE':'',
              'DESCRIBE':'',
              'clientTags':'',
              'group':'',
              'cpuQuotaPeriod':''
            }
          },
          //dynamic filter
          'dynamicFiltering':{
            'dynamicFiltering1':{
              'enable-dynamic-filtering':true,
              'dynamic-filtering-wait-time':'1s',
              'dynamic-filtering-data-type':'BLOOM_FILTER',
              'dynamic-filtering-max-size':1000000,
              'dynamic-filtering-max-per-driver-size':'1MB',
              'dynamic-filtering-max-per-driver-row-count':10000,
              'dynamic-filtering-bloom-filter-fpp':0.1,
              'hive.dynamic-filtering-row-filtering-threshold':5000,
              'hive.dynamic-filter-partition-filtering':false
            }
          },
          //state storage
          'stateStorage':{
            'stateStorage1':{
              'hetu.embedded-state-store.enabled':true,
              'state-store.type':'hazelcast',
              'state-store.name':'query',
              'state-store.cluster':'cluster1',
              'hazelcast.discovery.mode':'tcp-ip',
              'hazelcast.discovery.port':5701,
              'hazelcast.discovery.tcp-ip.seeds':'<member1_ip:member1_hazelcast.discovery.port>,<member2_ip:member2_hazelcast.discovery.port>,...',
              'hazelcast.discovery.tcp-ip.profile':'hdfs-config-default',
              'fs.client.type':'hdfs',
              'hdfs.config.resources':'<hdfs_config_dir>/core-site.xml,<hdfs_config_dir>/hdfs-site.xml',
              'hdfs.authentication.type':'NONE',
              'fs.hdfs.impl.disable.cache':true
            }
          },
          //metadata storage
          'metadataStore':{
            'metadataStore1':{
              'hetu.metastore.type':'jdbc',
              'hetu.metastore.db.url':'jdbc:mysql://....',
              'hetu.metastore.db.user':'root',
              'hetu.metastore.db.password':123456,
              'hetu.metastore.cache.type':'local',
              'hetu.metastore.hetufilesystem.profile-name':'hdfs-config-metastore',
              'hetu.metastore.hetufilesystem.path':'/etc/openlookeng/metastore',
              'hetu.metastore.cache.size':10000,
              'hetu.metastore.cache.ttl':0

            }
          },
          //audit log
          'auditLog':{
            'auditLog1':{
              'event-listener.name':'hetu-listener',
              'hetu.event.listener.type':'AUDIT',
              'hetu.event.listener.listen.query.creation':true,
              'hetu.event.listener.listen.query.completion':true,
              'hetu.event.listener.audit.file':'',
              'hetu.event.listener.audit.filecount':1,
              'hetu.event.listener.audit.limit':100000
            }
          },
          //LDAP authentication
          'LDAP':{
            'LDAP1':{
              'http-server.authentication.type':'PASSWORD',
              'http-server.https.enabled':false,
              'http-server.https.port':'',
              'http-server.https.keystore.path':'',
              'http-server.https.keystore.key':'',
              'http-server.authentication.password.user-mapping.pattern':'(.*)',
              'http-server.authentication.password.user-mapping.file':'',
              'password-authenticator.name':'ldap',
              'ldap.url':'ldaps://ldap-server:636',
              'ldap.user-bind-pattern':'<Refer below for usage>',
              'ldap.user-base-dn':'',
              'ldap.group-auth-pattern':''
            }
          }
        }
      }
    },
    methods: {
      getClusterConfig () {
        let apiUrl = '/sys_openlookeng_cluster_config/getClusterConfig'
        let param = {'clusterCode': this.clusterCode}
        let _this = this
        doGet(apiUrl, param).then((response) => {

          let findConfigData = response.data.data
          for (var key in findConfigData) {
            //debugger
            _this.data[key] = findConfigData[key]
          }

        })
      },

      handleClick (tab, event) {
        this.currentConfigType = tab.name
        // debugger
        console.log('切换了:' + tab.name)
      },
      handleTabsEdit (targetName, action) {
        let configType = this.currentConfigType
        let tabsArrayName = configType + 'Tabs'
        let tabsValName = configType + 'TabsValue'
        let tabsIndexName = configType + 'TabIndex'
        // debugger
        if (action === 'add') {
          let newTabName = ++this.data[configType][tabsIndexName] + ''
          let configGroup = configType + newTabName
          let obj = {
            title: '连接器' + newTabName,
            name: newTabName,
            configGroup: this.data[configType][tabsIndexName]
          }
          this.data[configType][tabsArrayName].push(obj)
          this.data[configType][tabsValName] = newTabName
          this.data[configType][configGroup] = {}
        }
        if (action === 'remove') {
          let tabs = this.data[configType][tabsArrayName]
          if (tabs.length == 1) {
            this.$message.error('请保留至少一个配置!')
            return false
          }
          let activeName = this.data[configType][tabsValName]
          if (activeName === targetName) {
            tabs.forEach((tab, index) => {
              if (tab.name === targetName) {
                let nextTab = tabs[index + 1] || tabs[index - 1]
                if (nextTab) {
                  activeName = nextTab.name
                }
              }
            })
          }
          this.data[configType][tabsValName] = activeName
          this.data[configType][tabsArrayName] = tabs.filter(tab => tab.name !== targetName)
        }
      },
      saveConfig (configType) {
        let data = this.data
        let apiUrl = '/sys_openlookeng_cluster_config/saveConfig?configType=' + configType + '&clusterCode=' + this.clusterCode
        let _this = this
        doPost(apiUrl, data).then((response) => {
          _this.$message.success('配置保存成功,重启集群生效!')
        })

      }

    }
  }
</script>
<style>
  .inputWidth {
    width: 230px;
  }
</style>
